#![cfg_attr(feature = "rt", feature(global_asm))]
#![cfg_attr(feature = "rt", feature(use_extern_macros))]
#![cfg_attr(feature = "rt", feature(used))]
#![doc = "Peripheral access API for TM4C129X microcontrollers (generated using svd2rust v0.12.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.12.1/svd2rust/#peripheral-api"]
#![allow(private_no_mangle_statics)]
#![deny(missing_docs)]
#![deny(warnings)]
#![allow(non_camel_case_types)]
#![feature(const_fn)]
#![feature(try_from)]
#![no_std]
extern crate cortex_m;
#[cfg(feature = "rt")]
extern crate cortex_m_rt;
#[cfg(feature = "rt")]
pub use cortex_m_rt::{default_handler, exception};
extern crate bare_metal;
extern crate vcell;
use core::marker::PhantomData;
use core::ops::Deref;
pub use interrupt::Interrupt;
#[doc(hidden)]
pub mod interrupt {
    use bare_metal::Nr;
    #[cfg(feature = "rt")]
    extern "C" {
        fn DEFAULT_HANDLER();
    }
    #[cfg(feature = "rt")]
    #[allow(non_snake_case)]
    #[no_mangle]
    pub unsafe extern "C" fn DH_TRAMPOLINE() {
        DEFAULT_HANDLER();
    }
    #[cfg(feature = "rt")]
    global_asm!("\n.weak GPIOA\nGPIOA = DH_TRAMPOLINE\n.weak GPIOB\nGPIOB = DH_TRAMPOLINE\n.weak GPIOC\nGPIOC = DH_TRAMPOLINE\n.weak GPIOD\nGPIOD = DH_TRAMPOLINE\n.weak GPIOE\nGPIOE = DH_TRAMPOLINE\n.weak UART0\nUART0 = DH_TRAMPOLINE\n.weak UART1\nUART1 = DH_TRAMPOLINE\n.weak SSI0\nSSI0 = DH_TRAMPOLINE\n.weak I2C0\nI2C0 = DH_TRAMPOLINE\n.weak PWM0_FAULT\nPWM0_FAULT = DH_TRAMPOLINE\n.weak PWM0_0\nPWM0_0 = DH_TRAMPOLINE\n.weak PWM0_1\nPWM0_1 = DH_TRAMPOLINE\n.weak PWM0_2\nPWM0_2 = DH_TRAMPOLINE\n.weak QEI0\nQEI0 = DH_TRAMPOLINE\n.weak ADC0SS0\nADC0SS0 = DH_TRAMPOLINE\n.weak ADC0SS1\nADC0SS1 = DH_TRAMPOLINE\n.weak ADC0SS2\nADC0SS2 = DH_TRAMPOLINE\n.weak ADC0SS3\nADC0SS3 = DH_TRAMPOLINE\n.weak WATCHDOG\nWATCHDOG = DH_TRAMPOLINE\n.weak TIMER0A\nTIMER0A = DH_TRAMPOLINE\n.weak TIMER0B\nTIMER0B = DH_TRAMPOLINE\n.weak TIMER1A\nTIMER1A = DH_TRAMPOLINE\n.weak TIMER1B\nTIMER1B = DH_TRAMPOLINE\n.weak TIMER2A\nTIMER2A = DH_TRAMPOLINE\n.weak TIMER2B\nTIMER2B = DH_TRAMPOLINE\n.weak COMP0\nCOMP0 = DH_TRAMPOLINE\n.weak COMP1\nCOMP1 = DH_TRAMPOLINE\n.weak COMP2\nCOMP2 = DH_TRAMPOLINE\n.weak SYSCTL\nSYSCTL = DH_TRAMPOLINE\n.weak FLASH\nFLASH = DH_TRAMPOLINE\n.weak GPIOF\nGPIOF = DH_TRAMPOLINE\n.weak GPIOG\nGPIOG = DH_TRAMPOLINE\n.weak GPIOH\nGPIOH = DH_TRAMPOLINE\n.weak UART2\nUART2 = DH_TRAMPOLINE\n.weak SSI1\nSSI1 = DH_TRAMPOLINE\n.weak TIMER3A\nTIMER3A = DH_TRAMPOLINE\n.weak TIMER3B\nTIMER3B = DH_TRAMPOLINE\n.weak I2C1\nI2C1 = DH_TRAMPOLINE\n.weak CAN0\nCAN0 = DH_TRAMPOLINE\n.weak CAN1\nCAN1 = DH_TRAMPOLINE\n.weak EMAC0\nEMAC0 = DH_TRAMPOLINE\n.weak HIBERNATE\nHIBERNATE = DH_TRAMPOLINE\n.weak USB0\nUSB0 = DH_TRAMPOLINE\n.weak PWM0_3\nPWM0_3 = DH_TRAMPOLINE\n.weak UDMA\nUDMA = DH_TRAMPOLINE\n.weak UDMAERR\nUDMAERR = DH_TRAMPOLINE\n.weak ADC1SS0\nADC1SS0 = DH_TRAMPOLINE\n.weak ADC1SS1\nADC1SS1 = DH_TRAMPOLINE\n.weak ADC1SS2\nADC1SS2 = DH_TRAMPOLINE\n.weak ADC1SS3\nADC1SS3 = DH_TRAMPOLINE\n.weak EPI0\nEPI0 = DH_TRAMPOLINE\n.weak GPIOJ\nGPIOJ = DH_TRAMPOLINE\n.weak GPIOK\nGPIOK = DH_TRAMPOLINE\n.weak GPIOL\nGPIOL = DH_TRAMPOLINE\n.weak SSI2\nSSI2 = DH_TRAMPOLINE\n.weak SSI3\nSSI3 = DH_TRAMPOLINE\n.weak UART3\nUART3 = DH_TRAMPOLINE\n.weak UART4\nUART4 = DH_TRAMPOLINE\n.weak UART5\nUART5 = DH_TRAMPOLINE\n.weak UART6\nUART6 = DH_TRAMPOLINE\n.weak UART7\nUART7 = DH_TRAMPOLINE\n.weak I2C2\nI2C2 = DH_TRAMPOLINE\n.weak I2C3\nI2C3 = DH_TRAMPOLINE\n.weak TIMER4A\nTIMER4A = DH_TRAMPOLINE\n.weak TIMER4B\nTIMER4B = DH_TRAMPOLINE\n.weak TIMER5A\nTIMER5A = DH_TRAMPOLINE\n.weak TIMER5B\nTIMER5B = DH_TRAMPOLINE\n.weak SYSEXC\nSYSEXC = DH_TRAMPOLINE\n.weak I2C4\nI2C4 = DH_TRAMPOLINE\n.weak I2C5\nI2C5 = DH_TRAMPOLINE\n.weak GPIOM\nGPIOM = DH_TRAMPOLINE\n.weak GPION\nGPION = DH_TRAMPOLINE\n.weak TAMPER0\nTAMPER0 = DH_TRAMPOLINE\n.weak GPIOP0\nGPIOP0 = DH_TRAMPOLINE\n.weak GPIOP1\nGPIOP1 = DH_TRAMPOLINE\n.weak GPIOP2\nGPIOP2 = DH_TRAMPOLINE\n.weak GPIOP3\nGPIOP3 = DH_TRAMPOLINE\n.weak GPIOP4\nGPIOP4 = DH_TRAMPOLINE\n.weak GPIOP5\nGPIOP5 = DH_TRAMPOLINE\n.weak GPIOP6\nGPIOP6 = DH_TRAMPOLINE\n.weak GPIOP7\nGPIOP7 = DH_TRAMPOLINE\n.weak GPIOQ0\nGPIOQ0 = DH_TRAMPOLINE\n.weak GPIOQ1\nGPIOQ1 = DH_TRAMPOLINE\n.weak GPIOQ2\nGPIOQ2 = DH_TRAMPOLINE\n.weak GPIOQ3\nGPIOQ3 = DH_TRAMPOLINE\n.weak GPIOQ4\nGPIOQ4 = DH_TRAMPOLINE\n.weak GPIOQ5\nGPIOQ5 = DH_TRAMPOLINE\n.weak GPIOQ6\nGPIOQ6 = DH_TRAMPOLINE\n.weak GPIOQ7\nGPIOQ7 = DH_TRAMPOLINE\n.weak GPIOR\nGPIOR = DH_TRAMPOLINE\n.weak GPIOS\nGPIOS = DH_TRAMPOLINE\n.weak SHA0\nSHA0 = DH_TRAMPOLINE\n.weak AES0\nAES0 = DH_TRAMPOLINE\n.weak DES0\nDES0 = DH_TRAMPOLINE\n.weak LCD0\nLCD0 = DH_TRAMPOLINE\n.weak TIMER6A\nTIMER6A = DH_TRAMPOLINE\n.weak TIMER6B\nTIMER6B = DH_TRAMPOLINE\n.weak TIMER7A\nTIMER7A = DH_TRAMPOLINE\n.weak TIMER7B\nTIMER7B = DH_TRAMPOLINE\n.weak I2C6\nI2C6 = DH_TRAMPOLINE\n.weak I2C7\nI2C7 = DH_TRAMPOLINE\n.weak ONEWIRE0\nONEWIRE0 = DH_TRAMPOLINE\n.weak I2C8\nI2C8 = DH_TRAMPOLINE\n.weak I2C9\nI2C9 = DH_TRAMPOLINE\n.weak GPIOT\nGPIOT = DH_TRAMPOLINE");
    #[cfg(feature = "rt")]
    extern "C" {
        fn GPIOA();
        fn GPIOB();
        fn GPIOC();
        fn GPIOD();
        fn GPIOE();
        fn UART0();
        fn UART1();
        fn SSI0();
        fn I2C0();
        fn PWM0_FAULT();
        fn PWM0_0();
        fn PWM0_1();
        fn PWM0_2();
        fn QEI0();
        fn ADC0SS0();
        fn ADC0SS1();
        fn ADC0SS2();
        fn ADC0SS3();
        fn WATCHDOG();
        fn TIMER0A();
        fn TIMER0B();
        fn TIMER1A();
        fn TIMER1B();
        fn TIMER2A();
        fn TIMER2B();
        fn COMP0();
        fn COMP1();
        fn COMP2();
        fn SYSCTL();
        fn FLASH();
        fn GPIOF();
        fn GPIOG();
        fn GPIOH();
        fn UART2();
        fn SSI1();
        fn TIMER3A();
        fn TIMER3B();
        fn I2C1();
        fn CAN0();
        fn CAN1();
        fn EMAC0();
        fn HIBERNATE();
        fn USB0();
        fn PWM0_3();
        fn UDMA();
        fn UDMAERR();
        fn ADC1SS0();
        fn ADC1SS1();
        fn ADC1SS2();
        fn ADC1SS3();
        fn EPI0();
        fn GPIOJ();
        fn GPIOK();
        fn GPIOL();
        fn SSI2();
        fn SSI3();
        fn UART3();
        fn UART4();
        fn UART5();
        fn UART6();
        fn UART7();
        fn I2C2();
        fn I2C3();
        fn TIMER4A();
        fn TIMER4B();
        fn TIMER5A();
        fn TIMER5B();
        fn SYSEXC();
        fn I2C4();
        fn I2C5();
        fn GPIOM();
        fn GPION();
        fn TAMPER0();
        fn GPIOP0();
        fn GPIOP1();
        fn GPIOP2();
        fn GPIOP3();
        fn GPIOP4();
        fn GPIOP5();
        fn GPIOP6();
        fn GPIOP7();
        fn GPIOQ0();
        fn GPIOQ1();
        fn GPIOQ2();
        fn GPIOQ3();
        fn GPIOQ4();
        fn GPIOQ5();
        fn GPIOQ6();
        fn GPIOQ7();
        fn GPIOR();
        fn GPIOS();
        fn SHA0();
        fn AES0();
        fn DES0();
        fn LCD0();
        fn TIMER6A();
        fn TIMER6B();
        fn TIMER7A();
        fn TIMER7B();
        fn I2C6();
        fn I2C7();
        fn ONEWIRE0();
        fn I2C8();
        fn I2C9();
        fn GPIOT();
    }
    #[allow(private_no_mangle_statics)]
    #[cfg(feature = "rt")]
    #[doc(hidden)]
    #[link_section = ".vector_table.interrupts"]
    #[no_mangle]
    #[used]
    pub static INTERRUPTS: [Option<unsafe extern "C" fn()>; 112] = [Some(GPIOA), Some(GPIOB), Some(GPIOC), Some(GPIOD), Some(GPIOE), Some(UART0), Some(UART1), Some(SSI0), Some(I2C0), Some(PWM0_FAULT), Some(PWM0_0), Some(PWM0_1), Some(PWM0_2), Some(QEI0), Some(ADC0SS0), Some(ADC0SS1), Some(ADC0SS2), Some(ADC0SS3), Some(WATCHDOG), Some(TIMER0A), Some(TIMER0B), Some(TIMER1A), Some(TIMER1B), Some(TIMER2A), Some(TIMER2B), Some(COMP0), Some(COMP1), Some(COMP2), Some(SYSCTL), Some(FLASH), Some(GPIOF), Some(GPIOG), Some(GPIOH), Some(UART2), Some(SSI1), Some(TIMER3A), Some(TIMER3B), Some(I2C1), Some(CAN0), Some(CAN1), Some(EMAC0), Some(HIBERNATE), Some(USB0), Some(PWM0_3), Some(UDMA), Some(UDMAERR), Some(ADC1SS0), Some(ADC1SS1), Some(ADC1SS2), Some(ADC1SS3), Some(EPI0), Some(GPIOJ), Some(GPIOK), Some(GPIOL), Some(SSI2), Some(SSI3), Some(UART3), Some(UART4), Some(UART5), Some(UART6), Some(UART7), Some(I2C2), Some(I2C3), Some(TIMER4A), Some(TIMER4B), Some(TIMER5A), Some(TIMER5B), Some(SYSEXC), None, None, Some(I2C4), Some(I2C5), Some(GPIOM), Some(GPION), None, Some(TAMPER0), Some(GPIOP0), Some(GPIOP1), Some(GPIOP2), Some(GPIOP3), Some(GPIOP4), Some(GPIOP5), Some(GPIOP6), Some(GPIOP7), Some(GPIOQ0), Some(GPIOQ1), Some(GPIOQ2), Some(GPIOQ3), Some(GPIOQ4), Some(GPIOQ5), Some(GPIOQ6), Some(GPIOQ7), Some(GPIOR), Some(GPIOS), Some(SHA0), Some(AES0), Some(DES0), Some(LCD0), Some(TIMER6A), Some(TIMER6B), Some(TIMER7A), Some(TIMER7B), Some(I2C6), Some(I2C7), None, Some(ONEWIRE0), None, None, None, Some(I2C8), Some(I2C9), Some(GPIOT)];
    #[doc = r" Enumeration of all the interrupts"]
    pub enum Interrupt {
        #[doc = "0 - GPIO Port A"]
        GPIOA,
        #[doc = "1 - GPIO Port B"]
        GPIOB,
        #[doc = "2 - GPIO Port C"]
        GPIOC,
        #[doc = "3 - GPIO Port D"]
        GPIOD,
        #[doc = "4 - GPIO Port E"]
        GPIOE,
        #[doc = "5 - UART0"]
        UART0,
        #[doc = "6 - UART1"]
        UART1,
        #[doc = "7 - SSI0"]
        SSI0,
        #[doc = "8 - I2C0"]
        I2C0,
        #[doc = "9 - PWM Fault"]
        PWM0_FAULT,
        #[doc = "10 - PWM Generator 0"]
        PWM0_0,
        #[doc = "11 - PWM Generator 1"]
        PWM0_1,
        #[doc = "12 - PWM Generator 2"]
        PWM0_2,
        #[doc = "13 - QEI0"]
        QEI0,
        #[doc = "14 - ADC0 Sequence 0"]
        ADC0SS0,
        #[doc = "15 - ADC0 Sequence 1"]
        ADC0SS1,
        #[doc = "16 - ADC0 Sequence 2"]
        ADC0SS2,
        #[doc = "17 - ADC0 Sequence 3"]
        ADC0SS3,
        #[doc = "18 - Watchdog Timers 0 and 1"]
        WATCHDOG,
        #[doc = "19 - 16/32-Bit Timer 0A"]
        TIMER0A,
        #[doc = "20 - 16/32-Bit Timer 0B"]
        TIMER0B,
        #[doc = "21 - 16/32-Bit Timer 1A"]
        TIMER1A,
        #[doc = "22 - 16/32-Bit Timer 1B"]
        TIMER1B,
        #[doc = "23 - 16/32-Bit Timer 2A"]
        TIMER2A,
        #[doc = "24 - 16/32-Bit Timer 2B"]
        TIMER2B,
        #[doc = "25 - Analog Comparator 0"]
        COMP0,
        #[doc = "26 - Analog Comparator 1"]
        COMP1,
        #[doc = "27 - Analog Comparator 2"]
        COMP2,
        #[doc = "28 - System Control"]
        SYSCTL,
        #[doc = "29 - Flash Memory Control"]
        FLASH,
        #[doc = "30 - GPIO Port F"]
        GPIOF,
        #[doc = "31 - GPIO Port G"]
        GPIOG,
        #[doc = "32 - GPIO Port H"]
        GPIOH,
        #[doc = "33 - UART2"]
        UART2,
        #[doc = "34 - SSI1"]
        SSI1,
        #[doc = "35 - 16/32-Bit Timer 3A"]
        TIMER3A,
        #[doc = "36 - 16/32-Bit Timer 3B"]
        TIMER3B,
        #[doc = "37 - I2C1"]
        I2C1,
        #[doc = "38 - CAN 0"]
        CAN0,
        #[doc = "39 - CAN1"]
        CAN1,
        #[doc = "40 - Ethernet MAC"]
        EMAC0,
        #[doc = "41 - HIB (Power Island)"]
        HIBERNATE,
        #[doc = "42 - USB MAC"]
        USB0,
        #[doc = "43 - PWM Generator 3"]
        PWM0_3,
        #[doc = "44 - uDMA 0 Software"]
        UDMA,
        #[doc = "45 - uDMA 0 Error"]
        UDMAERR,
        #[doc = "46 - ADC1 Sequence 0"]
        ADC1SS0,
        #[doc = "47 - ADC1 Sequence 1"]
        ADC1SS1,
        #[doc = "48 - ADC1 Sequence 2"]
        ADC1SS2,
        #[doc = "49 - ADC1 Sequence 3"]
        ADC1SS3,
        #[doc = "50 - EPI 0"]
        EPI0,
        #[doc = "51 - GPIO Port J"]
        GPIOJ,
        #[doc = "52 - GPIO Port K"]
        GPIOK,
        #[doc = "53 - GPIO Port L"]
        GPIOL,
        #[doc = "54 - SSI 2"]
        SSI2,
        #[doc = "55 - SSI 3"]
        SSI3,
        #[doc = "56 - UART 3"]
        UART3,
        #[doc = "57 - UART 4"]
        UART4,
        #[doc = "58 - UART 5"]
        UART5,
        #[doc = "59 - UART 6"]
        UART6,
        #[doc = "60 - UART 7"]
        UART7,
        #[doc = "61 - I2C 2"]
        I2C2,
        #[doc = "62 - I2C 3"]
        I2C3,
        #[doc = "63 - Timer 4A"]
        TIMER4A,
        #[doc = "64 - Timer 4B"]
        TIMER4B,
        #[doc = "65 - Timer 5A"]
        TIMER5A,
        #[doc = "66 - Timer 5B"]
        TIMER5B,
        #[doc = "67 - Floating-Point Exception (imprecise)"]
        SYSEXC,
        #[doc = "70 - I2C 4"]
        I2C4,
        #[doc = "71 - I2C 5"]
        I2C5,
        #[doc = "72 - GPIO Port M"]
        GPIOM,
        #[doc = "73 - GPIO Port N"]
        GPION,
        #[doc = "75 - Tamper"]
        TAMPER0,
        #[doc = "76 - GPIO Port P (Summary or P0)"]
        GPIOP0,
        #[doc = "77 - GPIO Port P1"]
        GPIOP1,
        #[doc = "78 - GPIO Port P2"]
        GPIOP2,
        #[doc = "79 - GPIO Port P3"]
        GPIOP3,
        #[doc = "80 - GPIO Port P4"]
        GPIOP4,
        #[doc = "81 - GPIO Port P5"]
        GPIOP5,
        #[doc = "82 - GPIO Port P6"]
        GPIOP6,
        #[doc = "83 - GPIO Port P7"]
        GPIOP7,
        #[doc = "84 - GPIO Port Q (Summary or Q0)"]
        GPIOQ0,
        #[doc = "85 - GPIO Port Q1"]
        GPIOQ1,
        #[doc = "86 - GPIO Port Q2"]
        GPIOQ2,
        #[doc = "87 - GPIO Port Q3"]
        GPIOQ3,
        #[doc = "88 - GPIO Port Q4"]
        GPIOQ4,
        #[doc = "89 - GPIO Port Q5"]
        GPIOQ5,
        #[doc = "90 - GPIO Port Q6"]
        GPIOQ6,
        #[doc = "91 - GPIO Port Q7"]
        GPIOQ7,
        #[doc = "92 - GPIO Port R"]
        GPIOR,
        #[doc = "93 - GPIO Port S"]
        GPIOS,
        #[doc = "94 - SHA/MD5"]
        SHA0,
        #[doc = "95 - AES"]
        AES0,
        #[doc = "96 - DES"]
        DES0,
        #[doc = "97 - LCD"]
        LCD0,
        #[doc = "98 - 16/32-Bit Timer 6A"]
        TIMER6A,
        #[doc = "99 - 16/32-Bit Timer 6B"]
        TIMER6B,
        #[doc = "100 - 16/32-Bit Timer 7A"]
        TIMER7A,
        #[doc = "101 - 16/32-Bit Timer 7B"]
        TIMER7B,
        #[doc = "102 - I2C 6"]
        I2C6,
        #[doc = "103 - I2C 7"]
        I2C7,
        #[doc = "105 - 1-Wire"]
        ONEWIRE0,
        #[doc = "109 - I2C 8"]
        I2C8,
        #[doc = "110 - I2C 9"]
        I2C9,
        #[doc = "111 - GPIO T"]
        GPIOT,
    }
    unsafe impl Nr for Interrupt {
        #[inline]
        fn nr(&self) -> u8 {
            match *self {
                Interrupt::GPIOA => 0,
                Interrupt::GPIOB => 1,
                Interrupt::GPIOC => 2,
                Interrupt::GPIOD => 3,
                Interrupt::GPIOE => 4,
                Interrupt::UART0 => 5,
                Interrupt::UART1 => 6,
                Interrupt::SSI0 => 7,
                Interrupt::I2C0 => 8,
                Interrupt::PWM0_FAULT => 9,
                Interrupt::PWM0_0 => 10,
                Interrupt::PWM0_1 => 11,
                Interrupt::PWM0_2 => 12,
                Interrupt::QEI0 => 13,
                Interrupt::ADC0SS0 => 14,
                Interrupt::ADC0SS1 => 15,
                Interrupt::ADC0SS2 => 16,
                Interrupt::ADC0SS3 => 17,
                Interrupt::WATCHDOG => 18,
                Interrupt::TIMER0A => 19,
                Interrupt::TIMER0B => 20,
                Interrupt::TIMER1A => 21,
                Interrupt::TIMER1B => 22,
                Interrupt::TIMER2A => 23,
                Interrupt::TIMER2B => 24,
                Interrupt::COMP0 => 25,
                Interrupt::COMP1 => 26,
                Interrupt::COMP2 => 27,
                Interrupt::SYSCTL => 28,
                Interrupt::FLASH => 29,
                Interrupt::GPIOF => 30,
                Interrupt::GPIOG => 31,
                Interrupt::GPIOH => 32,
                Interrupt::UART2 => 33,
                Interrupt::SSI1 => 34,
                Interrupt::TIMER3A => 35,
                Interrupt::TIMER3B => 36,
                Interrupt::I2C1 => 37,
                Interrupt::CAN0 => 38,
                Interrupt::CAN1 => 39,
                Interrupt::EMAC0 => 40,
                Interrupt::HIBERNATE => 41,
                Interrupt::USB0 => 42,
                Interrupt::PWM0_3 => 43,
                Interrupt::UDMA => 44,
                Interrupt::UDMAERR => 45,
                Interrupt::ADC1SS0 => 46,
                Interrupt::ADC1SS1 => 47,
                Interrupt::ADC1SS2 => 48,
                Interrupt::ADC1SS3 => 49,
                Interrupt::EPI0 => 50,
                Interrupt::GPIOJ => 51,
                Interrupt::GPIOK => 52,
                Interrupt::GPIOL => 53,
                Interrupt::SSI2 => 54,
                Interrupt::SSI3 => 55,
                Interrupt::UART3 => 56,
                Interrupt::UART4 => 57,
                Interrupt::UART5 => 58,
                Interrupt::UART6 => 59,
                Interrupt::UART7 => 60,
                Interrupt::I2C2 => 61,
                Interrupt::I2C3 => 62,
                Interrupt::TIMER4A => 63,
                Interrupt::TIMER4B => 64,
                Interrupt::TIMER5A => 65,
                Interrupt::TIMER5B => 66,
                Interrupt::SYSEXC => 67,
                Interrupt::I2C4 => 70,
                Interrupt::I2C5 => 71,
                Interrupt::GPIOM => 72,
                Interrupt::GPION => 73,
                Interrupt::TAMPER0 => 75,
                Interrupt::GPIOP0 => 76,
                Interrupt::GPIOP1 => 77,
                Interrupt::GPIOP2 => 78,
                Interrupt::GPIOP3 => 79,
                Interrupt::GPIOP4 => 80,
                Interrupt::GPIOP5 => 81,
                Interrupt::GPIOP6 => 82,
                Interrupt::GPIOP7 => 83,
                Interrupt::GPIOQ0 => 84,
                Interrupt::GPIOQ1 => 85,
                Interrupt::GPIOQ2 => 86,
                Interrupt::GPIOQ3 => 87,
                Interrupt::GPIOQ4 => 88,
                Interrupt::GPIOQ5 => 89,
                Interrupt::GPIOQ6 => 90,
                Interrupt::GPIOQ7 => 91,
                Interrupt::GPIOR => 92,
                Interrupt::GPIOS => 93,
                Interrupt::SHA0 => 94,
                Interrupt::AES0 => 95,
                Interrupt::DES0 => 96,
                Interrupt::LCD0 => 97,
                Interrupt::TIMER6A => 98,
                Interrupt::TIMER6B => 99,
                Interrupt::TIMER7A => 100,
                Interrupt::TIMER7B => 101,
                Interrupt::I2C6 => 102,
                Interrupt::I2C7 => 103,
                Interrupt::ONEWIRE0 => 105,
                Interrupt::I2C8 => 109,
                Interrupt::I2C9 => 110,
                Interrupt::GPIOT => 111,
            }
        }
    }
    use core::convert::TryFrom;
    #[derive(Debug, Copy, Clone)]
    pub struct TryFromInterruptError(());
    impl TryFrom<u8> for Interrupt {
        type Error = TryFromInterruptError;
        #[inline]
        fn try_from(value: u8) -> Result<Self, Self::Error> {
            match value {
                0 => Ok(Interrupt::GPIOA),
                1 => Ok(Interrupt::GPIOB),
                2 => Ok(Interrupt::GPIOC),
                3 => Ok(Interrupt::GPIOD),
                4 => Ok(Interrupt::GPIOE),
                5 => Ok(Interrupt::UART0),
                6 => Ok(Interrupt::UART1),
                7 => Ok(Interrupt::SSI0),
                8 => Ok(Interrupt::I2C0),
                9 => Ok(Interrupt::PWM0_FAULT),
                10 => Ok(Interrupt::PWM0_0),
                11 => Ok(Interrupt::PWM0_1),
                12 => Ok(Interrupt::PWM0_2),
                13 => Ok(Interrupt::QEI0),
                14 => Ok(Interrupt::ADC0SS0),
                15 => Ok(Interrupt::ADC0SS1),
                16 => Ok(Interrupt::ADC0SS2),
                17 => Ok(Interrupt::ADC0SS3),
                18 => Ok(Interrupt::WATCHDOG),
                19 => Ok(Interrupt::TIMER0A),
                20 => Ok(Interrupt::TIMER0B),
                21 => Ok(Interrupt::TIMER1A),
                22 => Ok(Interrupt::TIMER1B),
                23 => Ok(Interrupt::TIMER2A),
                24 => Ok(Interrupt::TIMER2B),
                25 => Ok(Interrupt::COMP0),
                26 => Ok(Interrupt::COMP1),
                27 => Ok(Interrupt::COMP2),
                28 => Ok(Interrupt::SYSCTL),
                29 => Ok(Interrupt::FLASH),
                30 => Ok(Interrupt::GPIOF),
                31 => Ok(Interrupt::GPIOG),
                32 => Ok(Interrupt::GPIOH),
                33 => Ok(Interrupt::UART2),
                34 => Ok(Interrupt::SSI1),
                35 => Ok(Interrupt::TIMER3A),
                36 => Ok(Interrupt::TIMER3B),
                37 => Ok(Interrupt::I2C1),
                38 => Ok(Interrupt::CAN0),
                39 => Ok(Interrupt::CAN1),
                40 => Ok(Interrupt::EMAC0),
                41 => Ok(Interrupt::HIBERNATE),
                42 => Ok(Interrupt::USB0),
                43 => Ok(Interrupt::PWM0_3),
                44 => Ok(Interrupt::UDMA),
                45 => Ok(Interrupt::UDMAERR),
                46 => Ok(Interrupt::ADC1SS0),
                47 => Ok(Interrupt::ADC1SS1),
                48 => Ok(Interrupt::ADC1SS2),
                49 => Ok(Interrupt::ADC1SS3),
                50 => Ok(Interrupt::EPI0),
                51 => Ok(Interrupt::GPIOJ),
                52 => Ok(Interrupt::GPIOK),
                53 => Ok(Interrupt::GPIOL),
                54 => Ok(Interrupt::SSI2),
                55 => Ok(Interrupt::SSI3),
                56 => Ok(Interrupt::UART3),
                57 => Ok(Interrupt::UART4),
                58 => Ok(Interrupt::UART5),
                59 => Ok(Interrupt::UART6),
                60 => Ok(Interrupt::UART7),
                61 => Ok(Interrupt::I2C2),
                62 => Ok(Interrupt::I2C3),
                63 => Ok(Interrupt::TIMER4A),
                64 => Ok(Interrupt::TIMER4B),
                65 => Ok(Interrupt::TIMER5A),
                66 => Ok(Interrupt::TIMER5B),
                67 => Ok(Interrupt::SYSEXC),
                70 => Ok(Interrupt::I2C4),
                71 => Ok(Interrupt::I2C5),
                72 => Ok(Interrupt::GPIOM),
                73 => Ok(Interrupt::GPION),
                75 => Ok(Interrupt::TAMPER0),
                76 => Ok(Interrupt::GPIOP0),
                77 => Ok(Interrupt::GPIOP1),
                78 => Ok(Interrupt::GPIOP2),
                79 => Ok(Interrupt::GPIOP3),
                80 => Ok(Interrupt::GPIOP4),
                81 => Ok(Interrupt::GPIOP5),
                82 => Ok(Interrupt::GPIOP6),
                83 => Ok(Interrupt::GPIOP7),
                84 => Ok(Interrupt::GPIOQ0),
                85 => Ok(Interrupt::GPIOQ1),
                86 => Ok(Interrupt::GPIOQ2),
                87 => Ok(Interrupt::GPIOQ3),
                88 => Ok(Interrupt::GPIOQ4),
                89 => Ok(Interrupt::GPIOQ5),
                90 => Ok(Interrupt::GPIOQ6),
                91 => Ok(Interrupt::GPIOQ7),
                92 => Ok(Interrupt::GPIOR),
                93 => Ok(Interrupt::GPIOS),
                94 => Ok(Interrupt::SHA0),
                95 => Ok(Interrupt::AES0),
                96 => Ok(Interrupt::DES0),
                97 => Ok(Interrupt::LCD0),
                98 => Ok(Interrupt::TIMER6A),
                99 => Ok(Interrupt::TIMER6B),
                100 => Ok(Interrupt::TIMER7A),
                101 => Ok(Interrupt::TIMER7B),
                102 => Ok(Interrupt::I2C6),
                103 => Ok(Interrupt::I2C7),
                105 => Ok(Interrupt::ONEWIRE0),
                109 => Ok(Interrupt::I2C8),
                110 => Ok(Interrupt::I2C9),
                111 => Ok(Interrupt::GPIOT),
                _ => Err(TryFromInterruptError(())),
            }
        }
    }
    #[cfg(feature = "rt")]
    #[macro_export]
    macro_rules ! interrupt { ( $ NAME : ident , $ path : path , locals : { $ ( $ lvar : ident : $ lty : ty = $ lval : expr ; ) * } ) => { # [ allow ( non_snake_case ) ] mod $ NAME { pub struct Locals { $ ( pub $ lvar : $ lty , ) * } } # [ allow ( non_snake_case ) ] # [ no_mangle ] pub extern "C" fn $ NAME ( ) { let _ = $ crate :: interrupt :: Interrupt :: $ NAME ; static mut LOCALS : self :: $ NAME :: Locals = self :: $ NAME :: Locals { $ ( $ lvar : $ lval , ) * } ; let f : fn ( & mut self :: $ NAME :: Locals ) = $ path ; f ( unsafe { & mut LOCALS } ) ; } } ; ( $ NAME : ident , $ path : path ) => { # [ allow ( non_snake_case ) ] # [ no_mangle ] pub extern "C" fn $ NAME ( ) { let _ = $ crate :: interrupt :: Interrupt :: $ NAME ; let f : fn ( ) = $ path ; f ( ) ; } } }
}
pub use cortex_m::peripheral::CPUID;
pub use cortex_m::peripheral::DCB;
pub use cortex_m::peripheral::DWT;
pub use cortex_m::peripheral::MPU;
pub use cortex_m::peripheral::NVIC;
pub use cortex_m::peripheral::Peripherals as CorePeripherals;
pub use cortex_m::peripheral::SCB;
pub use cortex_m::peripheral::SYST;
#[doc = "Watchdog Timer register offsets"]
pub struct WATCHDOG0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WATCHDOG0 {}
impl WATCHDOG0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const watchdog0::RegisterBlock {
        0x4000_0000 as *const _
    }
}
impl Deref for WATCHDOG0 {
    type Target = watchdog0::RegisterBlock;
    fn deref(&self) -> &watchdog0::RegisterBlock {
        unsafe { &*WATCHDOG0::ptr() }
    }
}
#[doc = "Watchdog Timer register offsets"]
pub mod watchdog0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Watchdog Load"]
        pub load: LOAD,
        #[doc = "0x04 - Watchdog Value"]
        pub value: VALUE,
        #[doc = "0x08 - Watchdog Control"]
        pub ctl: CTL,
        #[doc = "0x0c - Watchdog Interrupt Clear"]
        pub icr: ICR,
        #[doc = "0x10 - Watchdog Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x14 - Watchdog Masked Interrupt Status"]
        pub mis: MIS,
        _reserved0: [u8; 1024usize],
        #[doc = "0x418 - Watchdog Test"]
        pub test: TEST,
        _reserved1: [u8; 2020usize],
        #[doc = "0xc00 - Watchdog Lock"]
        pub lock: LOCK,
    }
    #[doc = "Watchdog Load"]
    pub struct LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Load"]
    pub mod load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Watchdog Value"]
    pub struct VALUE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Value"]
    pub mod value {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::VALUE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "Watchdog Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTENR {
            bits: bool,
        }
        impl INTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESENR {
            bits: bool,
        }
        impl RESENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTTYPER {
            bits: bool,
        }
        impl INTTYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCR {
            bits: bool,
        }
        impl WRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTTYPEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTTYPEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Interrupt Enable"]
            #[inline]
            pub fn inten(&self) -> INTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTENR { bits }
            }
            #[doc = "Bit 1 - Watchdog Reset Enable"]
            #[inline]
            pub fn resen(&self) -> RESENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RESENR { bits }
            }
            #[doc = "Bit 2 - Watchdog Interrupt Type"]
            #[inline]
            pub fn inttype(&self) -> INTTYPER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTTYPER { bits }
            }
            #[doc = "Bit 31 - Write Complete"]
            #[inline]
            pub fn wrc(&self) -> WRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCR { bits }
            }
        }
        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 = "Bit 0 - Watchdog Interrupt Enable"]
            #[inline]
            pub fn inten(&mut self) -> _INTENW {
                _INTENW { w: self }
            }
            #[doc = "Bit 1 - Watchdog Reset Enable"]
            #[inline]
            pub fn resen(&mut self) -> _RESENW {
                _RESENW { w: self }
            }
            #[doc = "Bit 2 - Watchdog Interrupt Type"]
            #[inline]
            pub fn inttype(&mut self) -> _INTTYPEW {
                _INTTYPEW { w: self }
            }
            #[doc = "Bit 31 - Write Complete"]
            #[inline]
            pub fn wrc(&mut self) -> _WRCW {
                _WRCW { w: self }
            }
        }
    }
    #[doc = "Watchdog Interrupt Clear"]
    pub struct ICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Interrupt Clear"]
    pub mod icr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ICR {
            #[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);
            }
        }
        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 = "Watchdog Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDTRISR {
            bits: bool,
        }
        impl WDTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Raw Interrupt Status"]
            #[inline]
            pub fn wdtris(&self) -> WDTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDTRISR { bits }
            }
        }
    }
    #[doc = "Watchdog Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDTMISR {
            bits: bool,
        }
        impl WDTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Masked Interrupt Status"]
            #[inline]
            pub fn wdtmis(&self) -> WDTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDTMISR { bits }
            }
        }
    }
    #[doc = "Watchdog Test"]
    pub struct TEST {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Test"]
    pub mod test {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TEST {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 8 - Watchdog Stall Enable"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STALLR { bits }
            }
        }
        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 = "Bit 8 - Watchdog Stall Enable"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
        }
    }
    #[doc = "Watchdog Lock"]
    pub struct LOCK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Lock"]
    pub mod lock {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LOCK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `LOCK`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum LOCKR {
            #[doc = "Unlocked"]
            UNLOCKED,
            #[doc = "Locked"]
            LOCKED,
            #[doc = "Unlocks the watchdog timer"]
            UNLOCK,
            #[doc = r" Reserved"]
            _Reserved(u32),
        }
        impl LOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                match *self {
                    LOCKR::UNLOCKED => 0,
                    LOCKR::LOCKED => 0x01,
                    LOCKR::UNLOCK => 0x1acc_e551,
                    LOCKR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u32) -> LOCKR {
                match value {
                    0 => LOCKR::UNLOCKED,
                    1 => LOCKR::LOCKED,
                    449635665 => LOCKR::UNLOCK,
                    i => LOCKR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `UNLOCKED`"]
            #[inline]
            pub fn is_unlocked(&self) -> bool {
                *self == LOCKR::UNLOCKED
            }
            #[doc = "Checks if the value of the field is `LOCKED`"]
            #[inline]
            pub fn is_locked(&self) -> bool {
                *self == LOCKR::LOCKED
            }
            #[doc = "Checks if the value of the field is `UNLOCK`"]
            #[inline]
            pub fn is_unlock(&self) -> bool {
                *self == LOCKR::UNLOCK
            }
        }
        #[doc = "Values that can be written to the field `LOCK`"]
        pub enum LOCKW {
            #[doc = "Unlocked"]
            UNLOCKED,
            #[doc = "Locked"]
            LOCKED,
            #[doc = "Unlocks the watchdog timer"]
            UNLOCK,
        }
        impl LOCKW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u32 {
                match *self {
                    LOCKW::UNLOCKED => 0,
                    LOCKW::LOCKED => 1,
                    LOCKW::UNLOCK => 449635665,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOCKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOCKW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: LOCKW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Unlocked"]
            #[inline]
            pub fn unlocked(self) -> &'a mut W {
                self.variant(LOCKW::UNLOCKED)
            }
            #[doc = "Locked"]
            #[inline]
            pub fn locked(self) -> &'a mut W {
                self.variant(LOCKW::LOCKED)
            }
            #[doc = "Unlocks the watchdog timer"]
            #[inline]
            pub fn unlock(self) -> &'a mut W {
                self.variant(LOCKW::UNLOCK)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Watchdog Lock"]
            #[inline]
            pub fn lock(&self) -> LOCKR {
                LOCKR::_from({
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                })
            }
        }
        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 0:31 - Watchdog Lock"]
            #[inline]
            pub fn lock(&mut self) -> _LOCKW {
                _LOCKW { w: self }
            }
        }
    }
}
#[doc = "WATCHDOG1"]
pub struct WATCHDOG1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for WATCHDOG1 {}
impl WATCHDOG1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const watchdog0::RegisterBlock {
        0x4000_1000 as *const _
    }
}
impl Deref for WATCHDOG1 {
    type Target = watchdog0::RegisterBlock;
    fn deref(&self) -> &watchdog0::RegisterBlock {
        unsafe { &*WATCHDOG1::ptr() }
    }
}
#[doc = "SSI register offsets"]
pub struct SSI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SSI0 {}
impl SSI0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const ssi0::RegisterBlock {
        0x4000_8000 as *const _
    }
}
impl Deref for SSI0 {
    type Target = ssi0::RegisterBlock;
    fn deref(&self) -> &ssi0::RegisterBlock {
        unsafe { &*SSI0::ptr() }
    }
}
#[doc = "SSI register offsets"]
pub mod ssi0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - SSI Control 0"]
        pub cr0: CR0,
        #[doc = "0x04 - SSI Control 1"]
        pub cr1: CR1,
        #[doc = "0x08 - SSI Data"]
        pub dr: DR,
        #[doc = "0x0c - SSI Status"]
        pub sr: SR,
        #[doc = "0x10 - SSI Clock Prescale"]
        pub cpsr: CPSR,
        #[doc = "0x14 - SSI Interrupt Mask"]
        pub im: IM,
        #[doc = "0x18 - SSI Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x1c - SSI Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x20 - SSI Interrupt Clear"]
        pub icr: ICR,
        #[doc = "0x24 - SSI DMA Control"]
        pub dmactl: DMACTL,
        _reserved0: [u8; 3992usize],
        #[doc = "0xfc0 - SSI Peripheral Properties"]
        pub pp: PP,
        _reserved1: [u8; 4usize],
        #[doc = "0xfc8 - SSI Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "SSI Control 0"]
    pub struct CR0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Control 0"]
    pub mod cr0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CR0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `DSS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DSSR {
            #[doc = "4-bit data"]
            _4,
            #[doc = "5-bit data"]
            _5,
            #[doc = "6-bit data"]
            _6,
            #[doc = "7-bit data"]
            _7,
            #[doc = "8-bit data"]
            _8,
            #[doc = "9-bit data"]
            _9,
            #[doc = "10-bit data"]
            _10,
            #[doc = "11-bit data"]
            _11,
            #[doc = "12-bit data"]
            _12,
            #[doc = "13-bit data"]
            _13,
            #[doc = "14-bit data"]
            _14,
            #[doc = "15-bit data"]
            _15,
            #[doc = "16-bit data"]
            _16,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DSSR::_4 => 0x03,
                    DSSR::_5 => 0x04,
                    DSSR::_6 => 0x05,
                    DSSR::_7 => 0x06,
                    DSSR::_8 => 0x07,
                    DSSR::_9 => 0x08,
                    DSSR::_10 => 0x09,
                    DSSR::_11 => 0x0a,
                    DSSR::_12 => 0x0b,
                    DSSR::_13 => 0x0c,
                    DSSR::_14 => 0x0d,
                    DSSR::_15 => 0x0e,
                    DSSR::_16 => 0x0f,
                    DSSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DSSR {
                match value {
                    3 => DSSR::_4,
                    4 => DSSR::_5,
                    5 => DSSR::_6,
                    6 => DSSR::_7,
                    7 => DSSR::_8,
                    8 => DSSR::_9,
                    9 => DSSR::_10,
                    10 => DSSR::_11,
                    11 => DSSR::_12,
                    12 => DSSR::_13,
                    13 => DSSR::_14,
                    14 => DSSR::_15,
                    15 => DSSR::_16,
                    i => DSSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == DSSR::_4
            }
            #[doc = "Checks if the value of the field is `_5`"]
            #[inline]
            pub fn is_5(&self) -> bool {
                *self == DSSR::_5
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == DSSR::_6
            }
            #[doc = "Checks if the value of the field is `_7`"]
            #[inline]
            pub fn is_7(&self) -> bool {
                *self == DSSR::_7
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == DSSR::_8
            }
            #[doc = "Checks if the value of the field is `_9`"]
            #[inline]
            pub fn is_9(&self) -> bool {
                *self == DSSR::_9
            }
            #[doc = "Checks if the value of the field is `_10`"]
            #[inline]
            pub fn is_10(&self) -> bool {
                *self == DSSR::_10
            }
            #[doc = "Checks if the value of the field is `_11`"]
            #[inline]
            pub fn is_11(&self) -> bool {
                *self == DSSR::_11
            }
            #[doc = "Checks if the value of the field is `_12`"]
            #[inline]
            pub fn is_12(&self) -> bool {
                *self == DSSR::_12
            }
            #[doc = "Checks if the value of the field is `_13`"]
            #[inline]
            pub fn is_13(&self) -> bool {
                *self == DSSR::_13
            }
            #[doc = "Checks if the value of the field is `_14`"]
            #[inline]
            pub fn is_14(&self) -> bool {
                *self == DSSR::_14
            }
            #[doc = "Checks if the value of the field is `_15`"]
            #[inline]
            pub fn is_15(&self) -> bool {
                *self == DSSR::_15
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == DSSR::_16
            }
        }
        #[doc = "Possible values of the field `FRF`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum FRFR {
            #[doc = "Freescale SPI Frame Format"]
            MOTO,
            #[doc = "Synchronous Serial Frame Format"]
            TI,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl FRFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    FRFR::MOTO => 0,
                    FRFR::TI => 0x01,
                    FRFR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> FRFR {
                match value {
                    0 => FRFR::MOTO,
                    1 => FRFR::TI,
                    i => FRFR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `MOTO`"]
            #[inline]
            pub fn is_moto(&self) -> bool {
                *self == FRFR::MOTO
            }
            #[doc = "Checks if the value of the field is `TI`"]
            #[inline]
            pub fn is_ti(&self) -> bool {
                *self == FRFR::TI
            }
        }
        #[doc = r" Value of the field"]
        pub struct SPOR {
            bits: bool,
        }
        impl SPOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SPHR {
            bits: bool,
        }
        impl SPHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SCRR {
            bits: u8,
        }
        impl SCRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Values that can be written to the field `DSS`"]
        pub enum DSSW {
            #[doc = "4-bit data"]
            _4,
            #[doc = "5-bit data"]
            _5,
            #[doc = "6-bit data"]
            _6,
            #[doc = "7-bit data"]
            _7,
            #[doc = "8-bit data"]
            _8,
            #[doc = "9-bit data"]
            _9,
            #[doc = "10-bit data"]
            _10,
            #[doc = "11-bit data"]
            _11,
            #[doc = "12-bit data"]
            _12,
            #[doc = "13-bit data"]
            _13,
            #[doc = "14-bit data"]
            _14,
            #[doc = "15-bit data"]
            _15,
            #[doc = "16-bit data"]
            _16,
        }
        impl DSSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DSSW::_4 => 3,
                    DSSW::_5 => 4,
                    DSSW::_6 => 5,
                    DSSW::_7 => 6,
                    DSSW::_8 => 7,
                    DSSW::_9 => 8,
                    DSSW::_10 => 9,
                    DSSW::_11 => 10,
                    DSSW::_12 => 11,
                    DSSW::_13 => 12,
                    DSSW::_14 => 13,
                    DSSW::_15 => 14,
                    DSSW::_16 => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DSSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "4-bit data"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(DSSW::_4)
            }
            #[doc = "5-bit data"]
            #[inline]
            pub fn _5(self) -> &'a mut W {
                self.variant(DSSW::_5)
            }
            #[doc = "6-bit data"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(DSSW::_6)
            }
            #[doc = "7-bit data"]
            #[inline]
            pub fn _7(self) -> &'a mut W {
                self.variant(DSSW::_7)
            }
            #[doc = "8-bit data"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(DSSW::_8)
            }
            #[doc = "9-bit data"]
            #[inline]
            pub fn _9(self) -> &'a mut W {
                self.variant(DSSW::_9)
            }
            #[doc = "10-bit data"]
            #[inline]
            pub fn _10(self) -> &'a mut W {
                self.variant(DSSW::_10)
            }
            #[doc = "11-bit data"]
            #[inline]
            pub fn _11(self) -> &'a mut W {
                self.variant(DSSW::_11)
            }
            #[doc = "12-bit data"]
            #[inline]
            pub fn _12(self) -> &'a mut W {
                self.variant(DSSW::_12)
            }
            #[doc = "13-bit data"]
            #[inline]
            pub fn _13(self) -> &'a mut W {
                self.variant(DSSW::_13)
            }
            #[doc = "14-bit data"]
            #[inline]
            pub fn _14(self) -> &'a mut W {
                self.variant(DSSW::_14)
            }
            #[doc = "15-bit data"]
            #[inline]
            pub fn _15(self) -> &'a mut W {
                self.variant(DSSW::_15)
            }
            #[doc = "16-bit data"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(DSSW::_16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `FRF`"]
        pub enum FRFW {
            #[doc = "Freescale SPI Frame Format"]
            MOTO,
            #[doc = "Synchronous Serial Frame Format"]
            TI,
        }
        impl FRFW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    FRFW::MOTO => 0,
                    FRFW::TI => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _FRFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FRFW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: FRFW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Freescale SPI Frame Format"]
            #[inline]
            pub fn moto(self) -> &'a mut W {
                self.variant(FRFW::MOTO)
            }
            #[doc = "Synchronous Serial Frame Format"]
            #[inline]
            pub fn ti(self) -> &'a mut W {
                self.variant(FRFW::TI)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPOW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPHW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SCRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SCRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - SSI Data Size Select"]
            #[inline]
            pub fn dss(&self) -> DSSR {
                DSSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - SSI Frame Format Select"]
            #[inline]
            pub fn frf(&self) -> FRFR {
                FRFR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 6 - SSI Serial Clock Polarity"]
            #[inline]
            pub fn spo(&self) -> SPOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SPOR { bits }
            }
            #[doc = "Bit 7 - SSI Serial Clock Phase"]
            #[inline]
            pub fn sph(&self) -> SPHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SPHR { bits }
            }
            #[doc = "Bits 8:15 - SSI Serial Clock Rate"]
            #[inline]
            pub fn scr(&self) -> SCRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SCRR { bits }
            }
        }
        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 0:3 - SSI Data Size Select"]
            #[inline]
            pub fn dss(&mut self) -> _DSSW {
                _DSSW { w: self }
            }
            #[doc = "Bits 4:5 - SSI Frame Format Select"]
            #[inline]
            pub fn frf(&mut self) -> _FRFW {
                _FRFW { w: self }
            }
            #[doc = "Bit 6 - SSI Serial Clock Polarity"]
            #[inline]
            pub fn spo(&mut self) -> _SPOW {
                _SPOW { w: self }
            }
            #[doc = "Bit 7 - SSI Serial Clock Phase"]
            #[inline]
            pub fn sph(&mut self) -> _SPHW {
                _SPHW { w: self }
            }
            #[doc = "Bits 8:15 - SSI Serial Clock Rate"]
            #[inline]
            pub fn scr(&mut self) -> _SCRW {
                _SCRW { w: self }
            }
        }
    }
    #[doc = "SSI Control 1"]
    pub struct CR1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Control 1"]
    pub mod cr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LBMR {
            bits: bool,
        }
        impl LBMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SSER {
            bits: bool,
        }
        impl SSER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSR {
            bits: bool,
        }
        impl MSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTR {
            bits: bool,
        }
        impl EOTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "Legacy SSI mode"]
            LEGACY,
            #[doc = "Bi-SSI mode"]
            BI,
            #[doc = "Quad-SSI Mode"]
            QUAD,
            #[doc = "Advanced SSI Mode with 8-bit packet size"]
            ADVANCED,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::LEGACY => 0,
                    MODER::BI => 0x01,
                    MODER::QUAD => 0x02,
                    MODER::ADVANCED => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::LEGACY,
                    1 => MODER::BI,
                    2 => MODER::QUAD,
                    3 => MODER::ADVANCED,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEGACY`"]
            #[inline]
            pub fn is_legacy(&self) -> bool {
                *self == MODER::LEGACY
            }
            #[doc = "Checks if the value of the field is `BI`"]
            #[inline]
            pub fn is_bi(&self) -> bool {
                *self == MODER::BI
            }
            #[doc = "Checks if the value of the field is `QUAD`"]
            #[inline]
            pub fn is_quad(&self) -> bool {
                *self == MODER::QUAD
            }
            #[doc = "Checks if the value of the field is `ADVANCED`"]
            #[inline]
            pub fn is_advanced(&self) -> bool {
                *self == MODER::ADVANCED
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSCLKENR {
            bits: bool,
        }
        impl HSCLKENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FSSHLDFRMR {
            bits: bool,
        }
        impl FSSHLDFRMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOMR {
            bits: bool,
        }
        impl EOMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _LBMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LBMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SSEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SSEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MSW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "Legacy SSI mode"]
            LEGACY,
            #[doc = "Bi-SSI mode"]
            BI,
            #[doc = "Quad-SSI Mode"]
            QUAD,
            #[doc = "Advanced SSI Mode with 8-bit packet size"]
            ADVANCED,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::LEGACY => 0,
                    MODEW::BI => 1,
                    MODEW::QUAD => 2,
                    MODEW::ADVANCED => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Legacy SSI mode"]
            #[inline]
            pub fn legacy(self) -> &'a mut W {
                self.variant(MODEW::LEGACY)
            }
            #[doc = "Bi-SSI mode"]
            #[inline]
            pub fn bi(self) -> &'a mut W {
                self.variant(MODEW::BI)
            }
            #[doc = "Quad-SSI Mode"]
            #[inline]
            pub fn quad(self) -> &'a mut W {
                self.variant(MODEW::QUAD)
            }
            #[doc = "Advanced SSI Mode with 8-bit packet size"]
            #[inline]
            pub fn advanced(self) -> &'a mut W {
                self.variant(MODEW::ADVANCED)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSCLKENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSCLKENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FSSHLDFRMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FSSHLDFRMW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOMW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Loopback Mode"]
            #[inline]
            pub fn lbm(&self) -> LBMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LBMR { bits }
            }
            #[doc = "Bit 1 - SSI Synchronous Serial Port Enable"]
            #[inline]
            pub fn sse(&self) -> SSER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SSER { bits }
            }
            #[doc = "Bit 2 - SSI Master/Slave Select"]
            #[inline]
            pub fn ms(&self) -> MSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSR { bits }
            }
            #[doc = "Bit 4 - End of Transmission"]
            #[inline]
            pub fn eot(&self) -> EOTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTR { bits }
            }
            #[doc = "Bits 6:7 - SSI Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 8 - SSI Direction of Operation"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 9 - High Speed Clock Enable"]
            #[inline]
            pub fn hsclken(&self) -> HSCLKENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSCLKENR { bits }
            }
            #[doc = "Bit 10 - FSS Hold Frame"]
            #[inline]
            pub fn fsshldfrm(&self) -> FSSHLDFRMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FSSHLDFRMR { bits }
            }
            #[doc = "Bit 11 - Stop Frame (End of Message)"]
            #[inline]
            pub fn eom(&self) -> EOMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOMR { bits }
            }
        }
        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 = "Bit 0 - SSI Loopback Mode"]
            #[inline]
            pub fn lbm(&mut self) -> _LBMW {
                _LBMW { w: self }
            }
            #[doc = "Bit 1 - SSI Synchronous Serial Port Enable"]
            #[inline]
            pub fn sse(&mut self) -> _SSEW {
                _SSEW { w: self }
            }
            #[doc = "Bit 2 - SSI Master/Slave Select"]
            #[inline]
            pub fn ms(&mut self) -> _MSW {
                _MSW { w: self }
            }
            #[doc = "Bit 4 - End of Transmission"]
            #[inline]
            pub fn eot(&mut self) -> _EOTW {
                _EOTW { w: self }
            }
            #[doc = "Bits 6:7 - SSI Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 8 - SSI Direction of Operation"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 9 - High Speed Clock Enable"]
            #[inline]
            pub fn hsclken(&mut self) -> _HSCLKENW {
                _HSCLKENW { w: self }
            }
            #[doc = "Bit 10 - FSS Hold Frame"]
            #[inline]
            pub fn fsshldfrm(&mut self) -> _FSSHLDFRMW {
                _FSSHLDFRMW { w: self }
            }
            #[doc = "Bit 11 - Stop Frame (End of Message)"]
            #[inline]
            pub fn eom(&mut self) -> _EOMW {
                _EOMW { w: self }
            }
        }
    }
    #[doc = "SSI Data"]
    pub struct DR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Data"]
    pub mod dr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - SSI Receive/Transmit Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - SSI Receive/Transmit Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "SSI Status"]
    pub struct SR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Status"]
    pub mod sr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TFER {
            bits: bool,
        }
        impl TFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TNFR {
            bits: bool,
        }
        impl TNFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RNER {
            bits: bool,
        }
        impl RNER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RFFR {
            bits: bool,
        }
        impl RFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BSYR {
            bits: bool,
        }
        impl BSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Transmit FIFO Empty"]
            #[inline]
            pub fn tfe(&self) -> TFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TFER { bits }
            }
            #[doc = "Bit 1 - SSI Transmit FIFO Not Full"]
            #[inline]
            pub fn tnf(&self) -> TNFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TNFR { bits }
            }
            #[doc = "Bit 2 - SSI Receive FIFO Not Empty"]
            #[inline]
            pub fn rne(&self) -> RNER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RNER { bits }
            }
            #[doc = "Bit 3 - SSI Receive FIFO Full"]
            #[inline]
            pub fn rff(&self) -> RFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RFFR { bits }
            }
            #[doc = "Bit 4 - SSI Busy Bit"]
            #[inline]
            pub fn bsy(&self) -> BSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BSYR { bits }
            }
        }
    }
    #[doc = "SSI Clock Prescale"]
    pub struct CPSR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Clock Prescale"]
    pub mod cpsr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CPSR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CPSDVSRR {
            bits: u8,
        }
        impl CPSDVSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CPSDVSRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CPSDVSRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - SSI Clock Prescale Divisor"]
            #[inline]
            pub fn cpsdvsr(&self) -> CPSDVSRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CPSDVSRR { bits }
            }
        }
        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 0:7 - SSI Clock Prescale Divisor"]
            #[inline]
            pub fn cpsdvsr(&mut self) -> _CPSDVSRW {
                _CPSDVSRW { w: self }
            }
        }
    }
    #[doc = "SSI Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RORIMR {
            bits: bool,
        }
        impl RORIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTIMR {
            bits: bool,
        }
        impl RTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIMR {
            bits: bool,
        }
        impl RXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIMR {
            bits: bool,
        }
        impl TXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXIMR {
            bits: bool,
        }
        impl DMARXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXIMR {
            bits: bool,
        }
        impl DMATXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTIMR {
            bits: bool,
        }
        impl EOTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RORIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RORIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTIMW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Receive Overrun Interrupt Mask"]
            #[inline]
            pub fn rorim(&self) -> RORIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RORIMR { bits }
            }
            #[doc = "Bit 1 - SSI Receive Time-Out Interrupt Mask"]
            #[inline]
            pub fn rtim(&self) -> RTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTIMR { bits }
            }
            #[doc = "Bit 2 - SSI Receive FIFO Interrupt Mask"]
            #[inline]
            pub fn rxim(&self) -> RXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIMR { bits }
            }
            #[doc = "Bit 3 - SSI Transmit FIFO Interrupt Mask"]
            #[inline]
            pub fn txim(&self) -> TXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIMR { bits }
            }
            #[doc = "Bit 4 - SSI Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&self) -> DMARXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXIMR { bits }
            }
            #[doc = "Bit 5 - SSI Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&self) -> DMATXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXIMR { bits }
            }
            #[doc = "Bit 6 - End of Transmit Interrupt Mask"]
            #[inline]
            pub fn eotim(&self) -> EOTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTIMR { bits }
            }
        }
        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 = "Bit 0 - SSI Receive Overrun Interrupt Mask"]
            #[inline]
            pub fn rorim(&mut self) -> _RORIMW {
                _RORIMW { w: self }
            }
            #[doc = "Bit 1 - SSI Receive Time-Out Interrupt Mask"]
            #[inline]
            pub fn rtim(&mut self) -> _RTIMW {
                _RTIMW { w: self }
            }
            #[doc = "Bit 2 - SSI Receive FIFO Interrupt Mask"]
            #[inline]
            pub fn rxim(&mut self) -> _RXIMW {
                _RXIMW { w: self }
            }
            #[doc = "Bit 3 - SSI Transmit FIFO Interrupt Mask"]
            #[inline]
            pub fn txim(&mut self) -> _TXIMW {
                _TXIMW { w: self }
            }
            #[doc = "Bit 4 - SSI Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&mut self) -> _DMARXIMW {
                _DMARXIMW { w: self }
            }
            #[doc = "Bit 5 - SSI Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&mut self) -> _DMATXIMW {
                _DMATXIMW { w: self }
            }
            #[doc = "Bit 6 - End of Transmit Interrupt Mask"]
            #[inline]
            pub fn eotim(&mut self) -> _EOTIMW {
                _EOTIMW { w: self }
            }
        }
    }
    #[doc = "SSI Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RORRISR {
            bits: bool,
        }
        impl RORRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTRISR {
            bits: bool,
        }
        impl RTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRISR {
            bits: bool,
        }
        impl RXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRISR {
            bits: bool,
        }
        impl TXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXRISR {
            bits: bool,
        }
        impl DMARXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXRISR {
            bits: bool,
        }
        impl DMATXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTRISR {
            bits: bool,
        }
        impl EOTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Receive Overrun Raw Interrupt Status"]
            #[inline]
            pub fn rorris(&self) -> RORRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RORRISR { bits }
            }
            #[doc = "Bit 1 - SSI Receive Time-Out Raw Interrupt Status"]
            #[inline]
            pub fn rtris(&self) -> RTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTRISR { bits }
            }
            #[doc = "Bit 2 - SSI Receive FIFO Raw Interrupt Status"]
            #[inline]
            pub fn rxris(&self) -> RXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXRISR { bits }
            }
            #[doc = "Bit 3 - SSI Transmit FIFO Raw Interrupt Status"]
            #[inline]
            pub fn txris(&self) -> TXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRISR { bits }
            }
            #[doc = "Bit 4 - SSI Receive DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmarxris(&self) -> DMARXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXRISR { bits }
            }
            #[doc = "Bit 5 - SSI Transmit DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmatxris(&self) -> DMATXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXRISR { bits }
            }
            #[doc = "Bit 6 - End of Transmit Raw Interrupt Status"]
            #[inline]
            pub fn eotris(&self) -> EOTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTRISR { bits }
            }
        }
    }
    #[doc = "SSI Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RORMISR {
            bits: bool,
        }
        impl RORMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTMISR {
            bits: bool,
        }
        impl RTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXMISR {
            bits: bool,
        }
        impl RXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXMISR {
            bits: bool,
        }
        impl TXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXMISR {
            bits: bool,
        }
        impl DMARXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXMISR {
            bits: bool,
        }
        impl DMATXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTMISR {
            bits: bool,
        }
        impl EOTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Receive Overrun Masked Interrupt Status"]
            #[inline]
            pub fn rormis(&self) -> RORMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RORMISR { bits }
            }
            #[doc = "Bit 1 - SSI Receive Time-Out Masked Interrupt Status"]
            #[inline]
            pub fn rtmis(&self) -> RTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTMISR { bits }
            }
            #[doc = "Bit 2 - SSI Receive FIFO Masked Interrupt Status"]
            #[inline]
            pub fn rxmis(&self) -> RXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXMISR { bits }
            }
            #[doc = "Bit 3 - SSI Transmit FIFO Masked Interrupt Status"]
            #[inline]
            pub fn txmis(&self) -> TXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXMISR { bits }
            }
            #[doc = "Bit 4 - SSI Receive DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmarxmis(&self) -> DMARXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXMISR { bits }
            }
            #[doc = "Bit 5 - SSI Transmit DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmatxmis(&self) -> DMATXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXMISR { bits }
            }
            #[doc = "Bit 6 - End of Transmit Masked Interrupt Status"]
            #[inline]
            pub fn eotmis(&self) -> EOTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTMISR { bits }
            }
        }
    }
    #[doc = "SSI Interrupt Clear"]
    pub struct ICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Interrupt Clear"]
    pub mod icr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ICR {
            #[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 _RORICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RORICW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTICW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXICW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTICW<'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 = 6;
                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 = "Bit 0 - SSI Receive Overrun Interrupt Clear"]
            #[inline]
            pub fn roric(&mut self) -> _RORICW {
                _RORICW { w: self }
            }
            #[doc = "Bit 1 - SSI Receive Time-Out Interrupt Clear"]
            #[inline]
            pub fn rtic(&mut self) -> _RTICW {
                _RTICW { w: self }
            }
            #[doc = "Bit 4 - SSI Receive DMA Interrupt Clear"]
            #[inline]
            pub fn dmarxic(&mut self) -> _DMARXICW {
                _DMARXICW { w: self }
            }
            #[doc = "Bit 5 - SSI Transmit DMA Interrupt Clear"]
            #[inline]
            pub fn dmatxic(&mut self) -> _DMATXICW {
                _DMATXICW { w: self }
            }
            #[doc = "Bit 6 - End of Transmit Interrupt Clear"]
            #[inline]
            pub fn eotic(&mut self) -> _EOTICW {
                _EOTICW { w: self }
            }
        }
    }
    #[doc = "SSI DMA Control"]
    pub struct DMACTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI DMA Control"]
    pub mod dmactl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXDMAER {
            bits: bool,
        }
        impl RXDMAER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXDMAER {
            bits: bool,
        }
        impl TXDMAER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXDMAEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXDMAEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXDMAEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXDMAEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Receive DMA Enable"]
            #[inline]
            pub fn rxdmae(&self) -> RXDMAER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXDMAER { bits }
            }
            #[doc = "Bit 1 - Transmit DMA Enable"]
            #[inline]
            pub fn txdmae(&self) -> TXDMAER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXDMAER { bits }
            }
        }
        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 = "Bit 0 - Receive DMA Enable"]
            #[inline]
            pub fn rxdmae(&mut self) -> _RXDMAEW {
                _RXDMAEW { w: self }
            }
            #[doc = "Bit 1 - Transmit DMA Enable"]
            #[inline]
            pub fn txdmae(&mut self) -> _TXDMAEW {
                _TXDMAEW { w: self }
            }
        }
    }
    #[doc = "SSI Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSCLKR {
            bits: bool,
        }
        impl HSCLKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "Legacy SSI mode"]
            LEGACY,
            #[doc = "Legacy mode, Advanced SSI mode and Bi-SSI mode enabled"]
            ADVBI,
            #[doc = "Legacy mode, Advanced mode, Bi-SSI and Quad-SSI mode enabled"]
            ADVBIQUAD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::LEGACY => 0,
                    MODER::ADVBI => 0x01,
                    MODER::ADVBIQUAD => 0x02,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::LEGACY,
                    1 => MODER::ADVBI,
                    2 => MODER::ADVBIQUAD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LEGACY`"]
            #[inline]
            pub fn is_legacy(&self) -> bool {
                *self == MODER::LEGACY
            }
            #[doc = "Checks if the value of the field is `ADVBI`"]
            #[inline]
            pub fn is_advbi(&self) -> bool {
                *self == MODER::ADVBI
            }
            #[doc = "Checks if the value of the field is `ADVBIQUAD`"]
            #[inline]
            pub fn is_advbiquad(&self) -> bool {
                *self == MODER::ADVBIQUAD
            }
        }
        #[doc = r" Value of the field"]
        pub struct FSSHLDFRMR {
            bits: bool,
        }
        impl FSSHLDFRMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - High Speed Capability"]
            #[inline]
            pub fn hsclk(&self) -> HSCLKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSCLKR { bits }
            }
            #[doc = "Bits 1:2 - Mode of Operation"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 3 - FSS Hold Frame Capability"]
            #[inline]
            pub fn fsshldfrm(&self) -> FSSHLDFRMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FSSHLDFRMR { bits }
            }
        }
    }
    #[doc = "SSI Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SSI Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CSR {
            #[doc = "System clock (based on clock source and divisor factor)"]
            SYSPLL,
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CSR::SYSPLL => 0,
                    CSR::PIOSC => 0x05,
                    CSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CSR {
                match value {
                    0 => CSR::SYSPLL,
                    5 => CSR::PIOSC,
                    i => CSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSPLL`"]
            #[inline]
            pub fn is_syspll(&self) -> bool {
                *self == CSR::SYSPLL
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == CSR::PIOSC
            }
        }
        #[doc = "Values that can be written to the field `CS`"]
        pub enum CSW {
            #[doc = "System clock (based on clock source and divisor factor)"]
            SYSPLL,
            #[doc = "PIOSC"]
            PIOSC,
        }
        impl CSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CSW::SYSPLL => 0,
                    CSW::PIOSC => 5,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "System clock (based on clock source and divisor factor)"]
            #[inline]
            pub fn syspll(self) -> &'a mut W {
                self.variant(CSW::SYSPLL)
            }
            #[doc = "PIOSC"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(CSW::PIOSC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - SSI Baud Clock Source"]
            #[inline]
            pub fn cs(&self) -> CSR {
                CSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - SSI Baud Clock Source"]
            #[inline]
            pub fn cs(&mut self) -> _CSW {
                _CSW { w: self }
            }
        }
    }
}
#[doc = "SSI1"]
pub struct SSI1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SSI1 {}
impl SSI1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const ssi0::RegisterBlock {
        0x4000_9000 as *const _
    }
}
impl Deref for SSI1 {
    type Target = ssi0::RegisterBlock;
    fn deref(&self) -> &ssi0::RegisterBlock {
        unsafe { &*SSI1::ptr() }
    }
}
#[doc = "SSI2"]
pub struct SSI2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SSI2 {}
impl SSI2 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const ssi0::RegisterBlock {
        0x4000_a000 as *const _
    }
}
impl Deref for SSI2 {
    type Target = ssi0::RegisterBlock;
    fn deref(&self) -> &ssi0::RegisterBlock {
        unsafe { &*SSI2::ptr() }
    }
}
#[doc = "SSI3"]
pub struct SSI3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SSI3 {}
impl SSI3 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const ssi0::RegisterBlock {
        0x4000_b000 as *const _
    }
}
impl Deref for SSI3 {
    type Target = ssi0::RegisterBlock;
    fn deref(&self) -> &ssi0::RegisterBlock {
        unsafe { &*SSI3::ptr() }
    }
}
#[doc = "UART register offsets"]
pub struct UART0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART0 {}
impl UART0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4000_c000 as *const _
    }
}
impl Deref for UART0 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART0::ptr() }
    }
}
#[doc = "UART register offsets"]
pub mod uart0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - UART Data"]
        pub dr: DR,
        #[doc = "0x04 - UART Receive Status/Error Clear"]
        pub rsr: RSR,
        _reserved0: [u8; 16usize],
        #[doc = "0x18 - UART Flag"]
        pub fr: FR,
        _reserved1: [u8; 4usize],
        #[doc = "0x20 - UART IrDA Low-Power Register"]
        pub ilpr: ILPR,
        #[doc = "0x24 - UART Integer Baud-Rate Divisor"]
        pub ibrd: IBRD,
        #[doc = "0x28 - UART Fractional Baud-Rate Divisor"]
        pub fbrd: FBRD,
        #[doc = "0x2c - UART Line Control"]
        pub lcrh: LCRH,
        #[doc = "0x30 - UART Control"]
        pub ctl: CTL,
        #[doc = "0x34 - UART Interrupt FIFO Level Select"]
        pub ifls: IFLS,
        #[doc = "0x38 - UART Interrupt Mask"]
        pub im: IM,
        #[doc = "0x3c - UART Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x40 - UART Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x44 - UART Interrupt Clear"]
        pub icr: ICR,
        #[doc = "0x48 - UART DMA Control"]
        pub dmactl: DMACTL,
        _reserved2: [u8; 88usize],
        #[doc = "0xa4 - UART 9-Bit Self Address"]
        pub _9bitaddr: _9BITADDR,
        #[doc = "0xa8 - UART 9-Bit Self Address Mask"]
        pub _9bitamask: _9BITAMASK,
        _reserved3: [u8; 3860usize],
        #[doc = "0xfc0 - UART Peripheral Properties"]
        pub pp: PP,
        _reserved4: [u8; 4usize],
        #[doc = "0xfc8 - UART Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "UART Data"]
    pub struct DR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Data"]
    pub mod dr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FER {
            bits: bool,
        }
        impl FER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PER {
            bits: bool,
        }
        impl PER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BER {
            bits: bool,
        }
        impl BER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OER {
            bits: bool,
        }
        impl OER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FEW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PEW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BEW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OEW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Data Transmitted or Received"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
            #[doc = "Bit 8 - UART Framing Error"]
            #[inline]
            pub fn fe(&self) -> FER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FER { bits }
            }
            #[doc = "Bit 9 - UART Parity Error"]
            #[inline]
            pub fn pe(&self) -> PER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PER { bits }
            }
            #[doc = "Bit 10 - UART Break Error"]
            #[inline]
            pub fn be(&self) -> BER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BER { bits }
            }
            #[doc = "Bit 11 - UART Overrun Error"]
            #[inline]
            pub fn oe(&self) -> OER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OER { bits }
            }
        }
        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 0:7 - Data Transmitted or Received"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
            #[doc = "Bit 8 - UART Framing Error"]
            #[inline]
            pub fn fe(&mut self) -> _FEW {
                _FEW { w: self }
            }
            #[doc = "Bit 9 - UART Parity Error"]
            #[inline]
            pub fn pe(&mut self) -> _PEW {
                _PEW { w: self }
            }
            #[doc = "Bit 10 - UART Break Error"]
            #[inline]
            pub fn be(&mut self) -> _BEW {
                _BEW { w: self }
            }
            #[doc = "Bit 11 - UART Overrun Error"]
            #[inline]
            pub fn oe(&mut self) -> _OEW {
                _OEW { w: self }
            }
        }
    }
    #[doc = "UART Receive Status/Error Clear"]
    pub struct RSR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Receive Status/Error Clear"]
    pub mod rsr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RSR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FER {
            bits: bool,
        }
        impl FER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PER {
            bits: bool,
        }
        impl PER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BER {
            bits: bool,
        }
        impl BER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OER {
            bits: bool,
        }
        impl OER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OEW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Framing Error"]
            #[inline]
            pub fn fe(&self) -> FER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FER { bits }
            }
            #[doc = "Bit 1 - UART Parity Error"]
            #[inline]
            pub fn pe(&self) -> PER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PER { bits }
            }
            #[doc = "Bit 2 - UART Break Error"]
            #[inline]
            pub fn be(&self) -> BER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BER { bits }
            }
            #[doc = "Bit 3 - UART Overrun Error"]
            #[inline]
            pub fn oe(&self) -> OER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OER { bits }
            }
        }
        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 = "Bit 0 - UART Framing Error"]
            #[inline]
            pub fn fe(&mut self) -> _FEW {
                _FEW { w: self }
            }
            #[doc = "Bit 1 - UART Parity Error"]
            #[inline]
            pub fn pe(&mut self) -> _PEW {
                _PEW { w: self }
            }
            #[doc = "Bit 2 - UART Break Error"]
            #[inline]
            pub fn be(&mut self) -> _BEW {
                _BEW { w: self }
            }
            #[doc = "Bit 3 - UART Overrun Error"]
            #[inline]
            pub fn oe(&mut self) -> _OEW {
                _OEW { w: self }
            }
        }
    }
    #[doc = "UART Receive Status/Error Clear"]
    pub struct ECR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Receive Status/Error Clear"]
    pub mod ecr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ECR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Error Clear"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
        }
        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 0:7 - Error Clear"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "UART Flag"]
    pub struct FR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Flag"]
    pub mod fr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::FR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTSR {
            bits: bool,
        }
        impl CTSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSRR {
            bits: bool,
        }
        impl DSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCDR {
            bits: bool,
        }
        impl DCDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSYR {
            bits: bool,
        }
        impl BUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFER {
            bits: bool,
        }
        impl RXFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFFR {
            bits: bool,
        }
        impl TXFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFR {
            bits: bool,
        }
        impl RXFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFER {
            bits: bool,
        }
        impl TXFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIR {
            bits: bool,
        }
        impl RIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Clear To Send"]
            #[inline]
            pub fn cts(&self) -> CTSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTSR { bits }
            }
            #[doc = "Bit 1 - Data Set Ready"]
            #[inline]
            pub fn dsr(&self) -> DSRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DSRR { bits }
            }
            #[doc = "Bit 2 - Data Carrier Detect"]
            #[inline]
            pub fn dcd(&self) -> DCDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCDR { bits }
            }
            #[doc = "Bit 3 - UART Busy"]
            #[inline]
            pub fn busy(&self) -> BUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSYR { bits }
            }
            #[doc = "Bit 4 - UART Receive FIFO Empty"]
            #[inline]
            pub fn rxfe(&self) -> RXFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFER { bits }
            }
            #[doc = "Bit 5 - UART Transmit FIFO Full"]
            #[inline]
            pub fn txff(&self) -> TXFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFFR { bits }
            }
            #[doc = "Bit 6 - UART Receive FIFO Full"]
            #[inline]
            pub fn rxff(&self) -> RXFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFR { bits }
            }
            #[doc = "Bit 7 - UART Transmit FIFO Empty"]
            #[inline]
            pub fn txfe(&self) -> TXFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFER { bits }
            }
            #[doc = "Bit 8 - Ring Indicator"]
            #[inline]
            pub fn ri(&self) -> RIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIR { bits }
            }
        }
    }
    #[doc = "UART IrDA Low-Power Register"]
    pub struct ILPR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART IrDA Low-Power Register"]
    pub mod ilpr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ILPR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ILPDVSRR {
            bits: u8,
        }
        impl ILPDVSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ILPDVSRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ILPDVSRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - IrDA Low-Power Divisor"]
            #[inline]
            pub fn ilpdvsr(&self) -> ILPDVSRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                ILPDVSRR { bits }
            }
        }
        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 0:7 - IrDA Low-Power Divisor"]
            #[inline]
            pub fn ilpdvsr(&mut self) -> _ILPDVSRW {
                _ILPDVSRW { w: self }
            }
        }
    }
    #[doc = "UART Integer Baud-Rate Divisor"]
    pub struct IBRD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Integer Baud-Rate Divisor"]
    pub mod ibrd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IBRD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIVINTR {
            bits: u16,
        }
        impl DIVINTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIVINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIVINTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Integer Baud-Rate Divisor"]
            #[inline]
            pub fn divint(&self) -> DIVINTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DIVINTR { bits }
            }
        }
        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 0:15 - Integer Baud-Rate Divisor"]
            #[inline]
            pub fn divint(&mut self) -> _DIVINTW {
                _DIVINTW { w: self }
            }
        }
    }
    #[doc = "UART Fractional Baud-Rate Divisor"]
    pub struct FBRD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Fractional Baud-Rate Divisor"]
    pub mod fbrd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FBRD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIVFRACR {
            bits: u8,
        }
        impl DIVFRACR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIVFRACW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIVFRACW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Fractional Baud-Rate Divisor"]
            #[inline]
            pub fn divfrac(&self) -> DIVFRACR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DIVFRACR { bits }
            }
        }
        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 0:5 - Fractional Baud-Rate Divisor"]
            #[inline]
            pub fn divfrac(&mut self) -> _DIVFRACW {
                _DIVFRACW { w: self }
            }
        }
    }
    #[doc = "UART Line Control"]
    pub struct LCRH {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Line Control"]
    pub mod lcrh {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LCRH {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BRKR {
            bits: bool,
        }
        impl BRKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PENR {
            bits: bool,
        }
        impl PENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPSR {
            bits: bool,
        }
        impl EPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STP2R {
            bits: bool,
        }
        impl STP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FENR {
            bits: bool,
        }
        impl FENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `WLEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WLENR {
            #[doc = "5 bits (default)"]
            _5,
            #[doc = "6 bits"]
            _6,
            #[doc = "7 bits"]
            _7,
            #[doc = "8 bits"]
            _8,
        }
        impl WLENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WLENR::_5 => 0,
                    WLENR::_6 => 0x01,
                    WLENR::_7 => 0x02,
                    WLENR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WLENR {
                match value {
                    0 => WLENR::_5,
                    1 => WLENR::_6,
                    2 => WLENR::_7,
                    3 => WLENR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_5`"]
            #[inline]
            pub fn is_5(&self) -> bool {
                *self == WLENR::_5
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WLENR::_6
            }
            #[doc = "Checks if the value of the field is `_7`"]
            #[inline]
            pub fn is_7(&self) -> bool {
                *self == WLENR::_7
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WLENR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct SPSR {
            bits: bool,
        }
        impl SPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRKW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPSW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _STP2W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WLEN`"]
        pub enum WLENW {
            #[doc = "5 bits (default)"]
            _5,
            #[doc = "6 bits"]
            _6,
            #[doc = "7 bits"]
            _7,
            #[doc = "8 bits"]
            _8,
        }
        impl WLENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WLENW::_5 => 0,
                    WLENW::_6 => 1,
                    WLENW::_7 => 2,
                    WLENW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WLENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WLENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WLENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "5 bits (default)"]
            #[inline]
            pub fn _5(self) -> &'a mut W {
                self.variant(WLENW::_5)
            }
            #[doc = "6 bits"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WLENW::_6)
            }
            #[doc = "7 bits"]
            #[inline]
            pub fn _7(self) -> &'a mut W {
                self.variant(WLENW::_7)
            }
            #[doc = "8 bits"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WLENW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _SPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Send Break"]
            #[inline]
            pub fn brk(&self) -> BRKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BRKR { bits }
            }
            #[doc = "Bit 1 - UART Parity Enable"]
            #[inline]
            pub fn pen(&self) -> PENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PENR { bits }
            }
            #[doc = "Bit 2 - UART Even Parity Select"]
            #[inline]
            pub fn eps(&self) -> EPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EPSR { bits }
            }
            #[doc = "Bit 3 - UART Two Stop Bits Select"]
            #[inline]
            pub fn stp2(&self) -> STP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STP2R { bits }
            }
            #[doc = "Bit 4 - UART Enable FIFOs"]
            #[inline]
            pub fn fen(&self) -> FENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FENR { bits }
            }
            #[doc = "Bits 5:6 - UART Word Length"]
            #[inline]
            pub fn wlen(&self) -> WLENR {
                WLENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - UART Stick Parity Select"]
            #[inline]
            pub fn sps(&self) -> SPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SPSR { bits }
            }
        }
        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 = "Bit 0 - UART Send Break"]
            #[inline]
            pub fn brk(&mut self) -> _BRKW {
                _BRKW { w: self }
            }
            #[doc = "Bit 1 - UART Parity Enable"]
            #[inline]
            pub fn pen(&mut self) -> _PENW {
                _PENW { w: self }
            }
            #[doc = "Bit 2 - UART Even Parity Select"]
            #[inline]
            pub fn eps(&mut self) -> _EPSW {
                _EPSW { w: self }
            }
            #[doc = "Bit 3 - UART Two Stop Bits Select"]
            #[inline]
            pub fn stp2(&mut self) -> _STP2W {
                _STP2W { w: self }
            }
            #[doc = "Bit 4 - UART Enable FIFOs"]
            #[inline]
            pub fn fen(&mut self) -> _FENW {
                _FENW { w: self }
            }
            #[doc = "Bits 5:6 - UART Word Length"]
            #[inline]
            pub fn wlen(&mut self) -> _WLENW {
                _WLENW { w: self }
            }
            #[doc = "Bit 7 - UART Stick Parity Select"]
            #[inline]
            pub fn sps(&mut self) -> _SPSW {
                _SPSW { w: self }
            }
        }
    }
    #[doc = "UART Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct UARTENR {
            bits: bool,
        }
        impl UARTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIRENR {
            bits: bool,
        }
        impl SIRENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIRLPR {
            bits: bool,
        }
        impl SIRLPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SMARTR {
            bits: bool,
        }
        impl SMARTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTR {
            bits: bool,
        }
        impl EOTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSER {
            bits: bool,
        }
        impl HSER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LBER {
            bits: bool,
        }
        impl LBER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXER {
            bits: bool,
        }
        impl TXER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXER {
            bits: bool,
        }
        impl RXER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTRR {
            bits: bool,
        }
        impl DTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTSR {
            bits: bool,
        }
        impl RTSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTSENR {
            bits: bool,
        }
        impl RTSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTSENR {
            bits: bool,
        }
        impl CTSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _UARTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UARTENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIRENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIRENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIRLPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIRLPW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SMARTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SMARTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LBEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LBEW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXEW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXEW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTRW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTSW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTSENW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTSENW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Enable"]
            #[inline]
            pub fn uarten(&self) -> UARTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UARTENR { bits }
            }
            #[doc = "Bit 1 - UART SIR Enable"]
            #[inline]
            pub fn siren(&self) -> SIRENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SIRENR { bits }
            }
            #[doc = "Bit 2 - UART SIR Low-Power Mode"]
            #[inline]
            pub fn sirlp(&self) -> SIRLPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SIRLPR { bits }
            }
            #[doc = "Bit 3 - ISO 7816 Smart Card Support"]
            #[inline]
            pub fn smart(&self) -> SMARTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SMARTR { bits }
            }
            #[doc = "Bit 4 - End of Transmission"]
            #[inline]
            pub fn eot(&self) -> EOTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTR { bits }
            }
            #[doc = "Bit 5 - High-Speed Enable"]
            #[inline]
            pub fn hse(&self) -> HSER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSER { bits }
            }
            #[doc = "Bit 7 - UART Loop Back Enable"]
            #[inline]
            pub fn lbe(&self) -> LBER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LBER { bits }
            }
            #[doc = "Bit 8 - UART Transmit Enable"]
            #[inline]
            pub fn txe(&self) -> TXER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXER { bits }
            }
            #[doc = "Bit 9 - UART Receive Enable"]
            #[inline]
            pub fn rxe(&self) -> RXER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXER { bits }
            }
            #[doc = "Bit 10 - Data Terminal Ready"]
            #[inline]
            pub fn dtr(&self) -> DTRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DTRR { bits }
            }
            #[doc = "Bit 11 - Request to Send"]
            #[inline]
            pub fn rts(&self) -> RTSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTSR { bits }
            }
            #[doc = "Bit 14 - Enable Request to Send"]
            #[inline]
            pub fn rtsen(&self) -> RTSENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTSENR { bits }
            }
            #[doc = "Bit 15 - Enable Clear To Send"]
            #[inline]
            pub fn ctsen(&self) -> CTSENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTSENR { bits }
            }
        }
        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 = "Bit 0 - UART Enable"]
            #[inline]
            pub fn uarten(&mut self) -> _UARTENW {
                _UARTENW { w: self }
            }
            #[doc = "Bit 1 - UART SIR Enable"]
            #[inline]
            pub fn siren(&mut self) -> _SIRENW {
                _SIRENW { w: self }
            }
            #[doc = "Bit 2 - UART SIR Low-Power Mode"]
            #[inline]
            pub fn sirlp(&mut self) -> _SIRLPW {
                _SIRLPW { w: self }
            }
            #[doc = "Bit 3 - ISO 7816 Smart Card Support"]
            #[inline]
            pub fn smart(&mut self) -> _SMARTW {
                _SMARTW { w: self }
            }
            #[doc = "Bit 4 - End of Transmission"]
            #[inline]
            pub fn eot(&mut self) -> _EOTW {
                _EOTW { w: self }
            }
            #[doc = "Bit 5 - High-Speed Enable"]
            #[inline]
            pub fn hse(&mut self) -> _HSEW {
                _HSEW { w: self }
            }
            #[doc = "Bit 7 - UART Loop Back Enable"]
            #[inline]
            pub fn lbe(&mut self) -> _LBEW {
                _LBEW { w: self }
            }
            #[doc = "Bit 8 - UART Transmit Enable"]
            #[inline]
            pub fn txe(&mut self) -> _TXEW {
                _TXEW { w: self }
            }
            #[doc = "Bit 9 - UART Receive Enable"]
            #[inline]
            pub fn rxe(&mut self) -> _RXEW {
                _RXEW { w: self }
            }
            #[doc = "Bit 10 - Data Terminal Ready"]
            #[inline]
            pub fn dtr(&mut self) -> _DTRW {
                _DTRW { w: self }
            }
            #[doc = "Bit 11 - Request to Send"]
            #[inline]
            pub fn rts(&mut self) -> _RTSW {
                _RTSW { w: self }
            }
            #[doc = "Bit 14 - Enable Request to Send"]
            #[inline]
            pub fn rtsen(&mut self) -> _RTSENW {
                _RTSENW { w: self }
            }
            #[doc = "Bit 15 - Enable Clear To Send"]
            #[inline]
            pub fn ctsen(&mut self) -> _CTSENW {
                _CTSENW { w: self }
            }
        }
    }
    #[doc = "UART Interrupt FIFO Level Select"]
    pub struct IFLS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Interrupt FIFO Level Select"]
    pub mod ifls {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IFLS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `TX`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TXR {
            #[doc = "TX FIFO &lt;= 1/8 full"]
            TX1_8,
            #[doc = "TX FIFO &lt;= 1/4 full"]
            TX2_8,
            #[doc = "TX FIFO &lt;= 1/2 full (default)"]
            TX4_8,
            #[doc = "TX FIFO &lt;= 3/4 full"]
            TX6_8,
            #[doc = "TX FIFO &lt;= 7/8 full"]
            TX7_8,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TXR::TX1_8 => 0,
                    TXR::TX2_8 => 0x01,
                    TXR::TX4_8 => 0x02,
                    TXR::TX6_8 => 0x03,
                    TXR::TX7_8 => 0x04,
                    TXR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TXR {
                match value {
                    0 => TXR::TX1_8,
                    1 => TXR::TX2_8,
                    2 => TXR::TX4_8,
                    3 => TXR::TX6_8,
                    4 => TXR::TX7_8,
                    i => TXR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `TX1_8`"]
            #[inline]
            pub fn is_tx1_8(&self) -> bool {
                *self == TXR::TX1_8
            }
            #[doc = "Checks if the value of the field is `TX2_8`"]
            #[inline]
            pub fn is_tx2_8(&self) -> bool {
                *self == TXR::TX2_8
            }
            #[doc = "Checks if the value of the field is `TX4_8`"]
            #[inline]
            pub fn is_tx4_8(&self) -> bool {
                *self == TXR::TX4_8
            }
            #[doc = "Checks if the value of the field is `TX6_8`"]
            #[inline]
            pub fn is_tx6_8(&self) -> bool {
                *self == TXR::TX6_8
            }
            #[doc = "Checks if the value of the field is `TX7_8`"]
            #[inline]
            pub fn is_tx7_8(&self) -> bool {
                *self == TXR::TX7_8
            }
        }
        #[doc = "Possible values of the field `RX`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RXR {
            #[doc = "RX FIFO >= 1/8 full"]
            RX1_8,
            #[doc = "RX FIFO >= 1/4 full"]
            RX2_8,
            #[doc = "RX FIFO >= 1/2 full (default)"]
            RX4_8,
            #[doc = "RX FIFO >= 3/4 full"]
            RX6_8,
            #[doc = "RX FIFO >= 7/8 full"]
            RX7_8,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl RXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RXR::RX1_8 => 0,
                    RXR::RX2_8 => 0x01,
                    RXR::RX4_8 => 0x02,
                    RXR::RX6_8 => 0x03,
                    RXR::RX7_8 => 0x04,
                    RXR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RXR {
                match value {
                    0 => RXR::RX1_8,
                    1 => RXR::RX2_8,
                    2 => RXR::RX4_8,
                    3 => RXR::RX6_8,
                    4 => RXR::RX7_8,
                    i => RXR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `RX1_8`"]
            #[inline]
            pub fn is_rx1_8(&self) -> bool {
                *self == RXR::RX1_8
            }
            #[doc = "Checks if the value of the field is `RX2_8`"]
            #[inline]
            pub fn is_rx2_8(&self) -> bool {
                *self == RXR::RX2_8
            }
            #[doc = "Checks if the value of the field is `RX4_8`"]
            #[inline]
            pub fn is_rx4_8(&self) -> bool {
                *self == RXR::RX4_8
            }
            #[doc = "Checks if the value of the field is `RX6_8`"]
            #[inline]
            pub fn is_rx6_8(&self) -> bool {
                *self == RXR::RX6_8
            }
            #[doc = "Checks if the value of the field is `RX7_8`"]
            #[inline]
            pub fn is_rx7_8(&self) -> bool {
                *self == RXR::RX7_8
            }
        }
        #[doc = "Values that can be written to the field `TX`"]
        pub enum TXW {
            #[doc = "TX FIFO &lt;= 1/8 full"]
            TX1_8,
            #[doc = "TX FIFO &lt;= 1/4 full"]
            TX2_8,
            #[doc = "TX FIFO &lt;= 1/2 full (default)"]
            TX4_8,
            #[doc = "TX FIFO &lt;= 3/4 full"]
            TX6_8,
            #[doc = "TX FIFO &lt;= 7/8 full"]
            TX7_8,
        }
        impl TXW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TXW::TX1_8 => 0,
                    TXW::TX2_8 => 1,
                    TXW::TX4_8 => 2,
                    TXW::TX6_8 => 3,
                    TXW::TX7_8 => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TXW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "TX FIFO &lt;= 1/8 full"]
            #[inline]
            pub fn tx1_8(self) -> &'a mut W {
                self.variant(TXW::TX1_8)
            }
            #[doc = "TX FIFO &lt;= 1/4 full"]
            #[inline]
            pub fn tx2_8(self) -> &'a mut W {
                self.variant(TXW::TX2_8)
            }
            #[doc = "TX FIFO &lt;= 1/2 full (default)"]
            #[inline]
            pub fn tx4_8(self) -> &'a mut W {
                self.variant(TXW::TX4_8)
            }
            #[doc = "TX FIFO &lt;= 3/4 full"]
            #[inline]
            pub fn tx6_8(self) -> &'a mut W {
                self.variant(TXW::TX6_8)
            }
            #[doc = "TX FIFO &lt;= 7/8 full"]
            #[inline]
            pub fn tx7_8(self) -> &'a mut W {
                self.variant(TXW::TX7_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RX`"]
        pub enum RXW {
            #[doc = "RX FIFO >= 1/8 full"]
            RX1_8,
            #[doc = "RX FIFO >= 1/4 full"]
            RX2_8,
            #[doc = "RX FIFO >= 1/2 full (default)"]
            RX4_8,
            #[doc = "RX FIFO >= 3/4 full"]
            RX6_8,
            #[doc = "RX FIFO >= 7/8 full"]
            RX7_8,
        }
        impl RXW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RXW::RX1_8 => 0,
                    RXW::RX2_8 => 1,
                    RXW::RX4_8 => 2,
                    RXW::RX6_8 => 3,
                    RXW::RX7_8 => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RXW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "RX FIFO >= 1/8 full"]
            #[inline]
            pub fn rx1_8(self) -> &'a mut W {
                self.variant(RXW::RX1_8)
            }
            #[doc = "RX FIFO >= 1/4 full"]
            #[inline]
            pub fn rx2_8(self) -> &'a mut W {
                self.variant(RXW::RX2_8)
            }
            #[doc = "RX FIFO >= 1/2 full (default)"]
            #[inline]
            pub fn rx4_8(self) -> &'a mut W {
                self.variant(RXW::RX4_8)
            }
            #[doc = "RX FIFO >= 3/4 full"]
            #[inline]
            pub fn rx6_8(self) -> &'a mut W {
                self.variant(RXW::RX6_8)
            }
            #[doc = "RX FIFO >= 7/8 full"]
            #[inline]
            pub fn rx7_8(self) -> &'a mut W {
                self.variant(RXW::RX7_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - UART Transmit Interrupt FIFO Level Select"]
            #[inline]
            pub fn tx(&self) -> TXR {
                TXR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 3:5 - UART Receive Interrupt FIFO Level Select"]
            #[inline]
            pub fn rx(&self) -> RXR {
                RXR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:2 - UART Transmit Interrupt FIFO Level Select"]
            #[inline]
            pub fn tx(&mut self) -> _TXW {
                _TXW { w: self }
            }
            #[doc = "Bits 3:5 - UART Receive Interrupt FIFO Level Select"]
            #[inline]
            pub fn rx(&mut self) -> _RXW {
                _RXW { w: self }
            }
        }
    }
    #[doc = "UART Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIMIMR {
            bits: bool,
        }
        impl RIMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTSMIMR {
            bits: bool,
        }
        impl CTSMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCDMIMR {
            bits: bool,
        }
        impl DCDMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSRMIMR {
            bits: bool,
        }
        impl DSRMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIMR {
            bits: bool,
        }
        impl RXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIMR {
            bits: bool,
        }
        impl TXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTIMR {
            bits: bool,
        }
        impl RTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FEIMR {
            bits: bool,
        }
        impl FEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PEIMR {
            bits: bool,
        }
        impl PEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BEIMR {
            bits: bool,
        }
        impl BEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OEIMR {
            bits: bool,
        }
        impl OEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTIMR {
            bits: bool,
        }
        impl EOTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct _9BITIMR {
            bits: bool,
        }
        impl _9BITIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXIMR {
            bits: bool,
        }
        impl DMARXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXIMR {
            bits: bool,
        }
        impl DMATXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RIMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIMIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTSMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTSMIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCDMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCDMIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSRMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSRMIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTIMW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FEIMW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PEIMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BEIMW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OEIMW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTIMW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct __9BITIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> __9BITIMW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXIMW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXIMW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Ring Indicator Modem Interrupt Mask"]
            #[inline]
            pub fn rimim(&self) -> RIMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIMIMR { bits }
            }
            #[doc = "Bit 1 - UART Clear to Send Modem Interrupt Mask"]
            #[inline]
            pub fn ctsmim(&self) -> CTSMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTSMIMR { bits }
            }
            #[doc = "Bit 2 - UART Data Carrier Detect Modem Interrupt Mask"]
            #[inline]
            pub fn dcdmim(&self) -> DCDMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCDMIMR { bits }
            }
            #[doc = "Bit 3 - UART Data Set Ready Modem Interrupt Mask"]
            #[inline]
            pub fn dsrmim(&self) -> DSRMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DSRMIMR { bits }
            }
            #[doc = "Bit 4 - UART Receive Interrupt Mask"]
            #[inline]
            pub fn rxim(&self) -> RXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIMR { bits }
            }
            #[doc = "Bit 5 - UART Transmit Interrupt Mask"]
            #[inline]
            pub fn txim(&self) -> TXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIMR { bits }
            }
            #[doc = "Bit 6 - UART Receive Time-Out Interrupt Mask"]
            #[inline]
            pub fn rtim(&self) -> RTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTIMR { bits }
            }
            #[doc = "Bit 7 - UART Framing Error Interrupt Mask"]
            #[inline]
            pub fn feim(&self) -> FEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FEIMR { bits }
            }
            #[doc = "Bit 8 - UART Parity Error Interrupt Mask"]
            #[inline]
            pub fn peim(&self) -> PEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PEIMR { bits }
            }
            #[doc = "Bit 9 - UART Break Error Interrupt Mask"]
            #[inline]
            pub fn beim(&self) -> BEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BEIMR { bits }
            }
            #[doc = "Bit 10 - UART Overrun Error Interrupt Mask"]
            #[inline]
            pub fn oeim(&self) -> OEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OEIMR { bits }
            }
            #[doc = "Bit 11 - End of Transmission Interrupt Mask"]
            #[inline]
            pub fn eotim(&self) -> EOTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTIMR { bits }
            }
            #[doc = "Bit 12 - 9-Bit Mode Interrupt Mask"]
            #[inline]
            pub fn _9bitim(&self) -> _9BITIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                _9BITIMR { bits }
            }
            #[doc = "Bit 16 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&self) -> DMARXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXIMR { bits }
            }
            #[doc = "Bit 17 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&self) -> DMATXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXIMR { bits }
            }
        }
        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 = "Bit 0 - UART Ring Indicator Modem Interrupt Mask"]
            #[inline]
            pub fn rimim(&mut self) -> _RIMIMW {
                _RIMIMW { w: self }
            }
            #[doc = "Bit 1 - UART Clear to Send Modem Interrupt Mask"]
            #[inline]
            pub fn ctsmim(&mut self) -> _CTSMIMW {
                _CTSMIMW { w: self }
            }
            #[doc = "Bit 2 - UART Data Carrier Detect Modem Interrupt Mask"]
            #[inline]
            pub fn dcdmim(&mut self) -> _DCDMIMW {
                _DCDMIMW { w: self }
            }
            #[doc = "Bit 3 - UART Data Set Ready Modem Interrupt Mask"]
            #[inline]
            pub fn dsrmim(&mut self) -> _DSRMIMW {
                _DSRMIMW { w: self }
            }
            #[doc = "Bit 4 - UART Receive Interrupt Mask"]
            #[inline]
            pub fn rxim(&mut self) -> _RXIMW {
                _RXIMW { w: self }
            }
            #[doc = "Bit 5 - UART Transmit Interrupt Mask"]
            #[inline]
            pub fn txim(&mut self) -> _TXIMW {
                _TXIMW { w: self }
            }
            #[doc = "Bit 6 - UART Receive Time-Out Interrupt Mask"]
            #[inline]
            pub fn rtim(&mut self) -> _RTIMW {
                _RTIMW { w: self }
            }
            #[doc = "Bit 7 - UART Framing Error Interrupt Mask"]
            #[inline]
            pub fn feim(&mut self) -> _FEIMW {
                _FEIMW { w: self }
            }
            #[doc = "Bit 8 - UART Parity Error Interrupt Mask"]
            #[inline]
            pub fn peim(&mut self) -> _PEIMW {
                _PEIMW { w: self }
            }
            #[doc = "Bit 9 - UART Break Error Interrupt Mask"]
            #[inline]
            pub fn beim(&mut self) -> _BEIMW {
                _BEIMW { w: self }
            }
            #[doc = "Bit 10 - UART Overrun Error Interrupt Mask"]
            #[inline]
            pub fn oeim(&mut self) -> _OEIMW {
                _OEIMW { w: self }
            }
            #[doc = "Bit 11 - End of Transmission Interrupt Mask"]
            #[inline]
            pub fn eotim(&mut self) -> _EOTIMW {
                _EOTIMW { w: self }
            }
            #[doc = "Bit 12 - 9-Bit Mode Interrupt Mask"]
            #[inline]
            pub fn _9bitim(&mut self) -> __9BITIMW {
                __9BITIMW { w: self }
            }
            #[doc = "Bit 16 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&mut self) -> _DMARXIMW {
                _DMARXIMW { w: self }
            }
            #[doc = "Bit 17 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&mut self) -> _DMATXIMW {
                _DMATXIMW { w: self }
            }
        }
    }
    #[doc = "UART Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIRISR {
            bits: bool,
        }
        impl RIRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTSRISR {
            bits: bool,
        }
        impl CTSRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCDRISR {
            bits: bool,
        }
        impl DCDRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSRRISR {
            bits: bool,
        }
        impl DSRRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRISR {
            bits: bool,
        }
        impl RXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRISR {
            bits: bool,
        }
        impl TXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTRISR {
            bits: bool,
        }
        impl RTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FERISR {
            bits: bool,
        }
        impl FERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PERISR {
            bits: bool,
        }
        impl PERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BERISR {
            bits: bool,
        }
        impl BERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OERISR {
            bits: bool,
        }
        impl OERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTRISR {
            bits: bool,
        }
        impl EOTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct _9BITRISR {
            bits: bool,
        }
        impl _9BITRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXRISR {
            bits: bool,
        }
        impl DMARXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXRISR {
            bits: bool,
        }
        impl DMATXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Ring Indicator Modem Raw Interrupt Status"]
            #[inline]
            pub fn riris(&self) -> RIRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIRISR { bits }
            }
            #[doc = "Bit 1 - UART Clear to Send Modem Raw Interrupt Status"]
            #[inline]
            pub fn ctsris(&self) -> CTSRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTSRISR { bits }
            }
            #[doc = "Bit 2 - UART Data Carrier Detect Modem Raw Interrupt Status"]
            #[inline]
            pub fn dcdris(&self) -> DCDRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCDRISR { bits }
            }
            #[doc = "Bit 3 - UART Data Set Ready Modem Raw Interrupt Status"]
            #[inline]
            pub fn dsrris(&self) -> DSRRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DSRRISR { bits }
            }
            #[doc = "Bit 4 - UART Receive Raw Interrupt Status"]
            #[inline]
            pub fn rxris(&self) -> RXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXRISR { bits }
            }
            #[doc = "Bit 5 - UART Transmit Raw Interrupt Status"]
            #[inline]
            pub fn txris(&self) -> TXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRISR { bits }
            }
            #[doc = "Bit 6 - UART Receive Time-Out Raw Interrupt Status"]
            #[inline]
            pub fn rtris(&self) -> RTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTRISR { bits }
            }
            #[doc = "Bit 7 - UART Framing Error Raw Interrupt Status"]
            #[inline]
            pub fn feris(&self) -> FERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FERISR { bits }
            }
            #[doc = "Bit 8 - UART Parity Error Raw Interrupt Status"]
            #[inline]
            pub fn peris(&self) -> PERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PERISR { bits }
            }
            #[doc = "Bit 9 - UART Break Error Raw Interrupt Status"]
            #[inline]
            pub fn beris(&self) -> BERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BERISR { bits }
            }
            #[doc = "Bit 10 - UART Overrun Error Raw Interrupt Status"]
            #[inline]
            pub fn oeris(&self) -> OERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OERISR { bits }
            }
            #[doc = "Bit 11 - End of Transmission Raw Interrupt Status"]
            #[inline]
            pub fn eotris(&self) -> EOTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTRISR { bits }
            }
            #[doc = "Bit 12 - 9-Bit Mode Raw Interrupt Status"]
            #[inline]
            pub fn _9bitris(&self) -> _9BITRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                _9BITRISR { bits }
            }
            #[doc = "Bit 16 - Receive DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmarxris(&self) -> DMARXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXRISR { bits }
            }
            #[doc = "Bit 17 - Transmit DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmatxris(&self) -> DMATXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXRISR { bits }
            }
        }
    }
    #[doc = "UART Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIMISR {
            bits: bool,
        }
        impl RIMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTSMISR {
            bits: bool,
        }
        impl CTSMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCDMISR {
            bits: bool,
        }
        impl DCDMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSRMISR {
            bits: bool,
        }
        impl DSRMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXMISR {
            bits: bool,
        }
        impl RXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXMISR {
            bits: bool,
        }
        impl TXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTMISR {
            bits: bool,
        }
        impl RTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FEMISR {
            bits: bool,
        }
        impl FEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PEMISR {
            bits: bool,
        }
        impl PEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BEMISR {
            bits: bool,
        }
        impl BEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OEMISR {
            bits: bool,
        }
        impl OEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOTMISR {
            bits: bool,
        }
        impl EOTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct _9BITMISR {
            bits: bool,
        }
        impl _9BITMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXMISR {
            bits: bool,
        }
        impl DMARXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXMISR {
            bits: bool,
        }
        impl DMATXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Ring Indicator Modem Masked Interrupt Status"]
            #[inline]
            pub fn rimis(&self) -> RIMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIMISR { bits }
            }
            #[doc = "Bit 1 - UART Clear to Send Modem Masked Interrupt Status"]
            #[inline]
            pub fn ctsmis(&self) -> CTSMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTSMISR { bits }
            }
            #[doc = "Bit 2 - UART Data Carrier Detect Modem Masked Interrupt Status"]
            #[inline]
            pub fn dcdmis(&self) -> DCDMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCDMISR { bits }
            }
            #[doc = "Bit 3 - UART Data Set Ready Modem Masked Interrupt Status"]
            #[inline]
            pub fn dsrmis(&self) -> DSRMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DSRMISR { bits }
            }
            #[doc = "Bit 4 - UART Receive Masked Interrupt Status"]
            #[inline]
            pub fn rxmis(&self) -> RXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXMISR { bits }
            }
            #[doc = "Bit 5 - UART Transmit Masked Interrupt Status"]
            #[inline]
            pub fn txmis(&self) -> TXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXMISR { bits }
            }
            #[doc = "Bit 6 - UART Receive Time-Out Masked Interrupt Status"]
            #[inline]
            pub fn rtmis(&self) -> RTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTMISR { bits }
            }
            #[doc = "Bit 7 - UART Framing Error Masked Interrupt Status"]
            #[inline]
            pub fn femis(&self) -> FEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FEMISR { bits }
            }
            #[doc = "Bit 8 - UART Parity Error Masked Interrupt Status"]
            #[inline]
            pub fn pemis(&self) -> PEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PEMISR { bits }
            }
            #[doc = "Bit 9 - UART Break Error Masked Interrupt Status"]
            #[inline]
            pub fn bemis(&self) -> BEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BEMISR { bits }
            }
            #[doc = "Bit 10 - UART Overrun Error Masked Interrupt Status"]
            #[inline]
            pub fn oemis(&self) -> OEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OEMISR { bits }
            }
            #[doc = "Bit 11 - End of Transmission Masked Interrupt Status"]
            #[inline]
            pub fn eotmis(&self) -> EOTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOTMISR { bits }
            }
            #[doc = "Bit 12 - 9-Bit Mode Masked Interrupt Status"]
            #[inline]
            pub fn _9bitmis(&self) -> _9BITMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                _9BITMISR { bits }
            }
            #[doc = "Bit 16 - Receive DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmarxmis(&self) -> DMARXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXMISR { bits }
            }
            #[doc = "Bit 17 - Transmit DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmatxmis(&self) -> DMATXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXMISR { bits }
            }
        }
    }
    #[doc = "UART Interrupt Clear"]
    pub struct ICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Interrupt Clear"]
    pub mod icr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ICR {
            #[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 _RIMICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIMICW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTSMICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTSMICW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCDMICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCDMICW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSRMICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSRMICW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXICW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTICW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FEICW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PEICW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BEICW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OEICW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOTICW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct __9BITICW<'a> {
            w: &'a mut W,
        }
        impl<'a> __9BITICW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXICW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXICW<'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 = 17;
                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 = "Bit 0 - UART Ring Indicator Modem Interrupt Clear"]
            #[inline]
            pub fn rimic(&mut self) -> _RIMICW {
                _RIMICW { w: self }
            }
            #[doc = "Bit 1 - UART Clear to Send Modem Interrupt Clear"]
            #[inline]
            pub fn ctsmic(&mut self) -> _CTSMICW {
                _CTSMICW { w: self }
            }
            #[doc = "Bit 2 - UART Data Carrier Detect Modem Interrupt Clear"]
            #[inline]
            pub fn dcdmic(&mut self) -> _DCDMICW {
                _DCDMICW { w: self }
            }
            #[doc = "Bit 3 - UART Data Set Ready Modem Interrupt Clear"]
            #[inline]
            pub fn dsrmic(&mut self) -> _DSRMICW {
                _DSRMICW { w: self }
            }
            #[doc = "Bit 4 - Receive Interrupt Clear"]
            #[inline]
            pub fn rxic(&mut self) -> _RXICW {
                _RXICW { w: self }
            }
            #[doc = "Bit 5 - Transmit Interrupt Clear"]
            #[inline]
            pub fn txic(&mut self) -> _TXICW {
                _TXICW { w: self }
            }
            #[doc = "Bit 6 - Receive Time-Out Interrupt Clear"]
            #[inline]
            pub fn rtic(&mut self) -> _RTICW {
                _RTICW { w: self }
            }
            #[doc = "Bit 7 - Framing Error Interrupt Clear"]
            #[inline]
            pub fn feic(&mut self) -> _FEICW {
                _FEICW { w: self }
            }
            #[doc = "Bit 8 - Parity Error Interrupt Clear"]
            #[inline]
            pub fn peic(&mut self) -> _PEICW {
                _PEICW { w: self }
            }
            #[doc = "Bit 9 - Break Error Interrupt Clear"]
            #[inline]
            pub fn beic(&mut self) -> _BEICW {
                _BEICW { w: self }
            }
            #[doc = "Bit 10 - Overrun Error Interrupt Clear"]
            #[inline]
            pub fn oeic(&mut self) -> _OEICW {
                _OEICW { w: self }
            }
            #[doc = "Bit 11 - End of Transmission Interrupt Clear"]
            #[inline]
            pub fn eotic(&mut self) -> _EOTICW {
                _EOTICW { w: self }
            }
            #[doc = "Bit 12 - 9-Bit Mode Interrupt Clear"]
            #[inline]
            pub fn _9bitic(&mut self) -> __9BITICW {
                __9BITICW { w: self }
            }
            #[doc = "Bit 16 - Receive DMA Interrupt Clear"]
            #[inline]
            pub fn dmarxic(&mut self) -> _DMARXICW {
                _DMARXICW { w: self }
            }
            #[doc = "Bit 17 - Transmit DMA Interrupt Clear"]
            #[inline]
            pub fn dmatxic(&mut self) -> _DMATXICW {
                _DMATXICW { w: self }
            }
        }
    }
    #[doc = "UART DMA Control"]
    pub struct DMACTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART DMA Control"]
    pub mod dmactl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXDMAER {
            bits: bool,
        }
        impl RXDMAER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXDMAER {
            bits: bool,
        }
        impl TXDMAER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAERRR {
            bits: bool,
        }
        impl DMAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXDMAEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXDMAEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXDMAEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXDMAEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAERRW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Receive DMA Enable"]
            #[inline]
            pub fn rxdmae(&self) -> RXDMAER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXDMAER { bits }
            }
            #[doc = "Bit 1 - Transmit DMA Enable"]
            #[inline]
            pub fn txdmae(&self) -> TXDMAER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXDMAER { bits }
            }
            #[doc = "Bit 2 - DMA on Error"]
            #[inline]
            pub fn dmaerr(&self) -> DMAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAERRR { bits }
            }
        }
        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 = "Bit 0 - Receive DMA Enable"]
            #[inline]
            pub fn rxdmae(&mut self) -> _RXDMAEW {
                _RXDMAEW { w: self }
            }
            #[doc = "Bit 1 - Transmit DMA Enable"]
            #[inline]
            pub fn txdmae(&mut self) -> _TXDMAEW {
                _TXDMAEW { w: self }
            }
            #[doc = "Bit 2 - DMA on Error"]
            #[inline]
            pub fn dmaerr(&mut self) -> _DMAERRW {
                _DMAERRW { w: self }
            }
        }
    }
    #[doc = "UART 9-Bit Self Address"]
    pub struct _9BITADDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART 9-Bit Self Address"]
    pub mod _9bitaddr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_9BITADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct _9BITENR {
            bits: bool,
        }
        impl _9BITENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct __9BITENW<'a> {
            w: &'a mut W,
        }
        impl<'a> __9BITENW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Self Address for 9-Bit Mode"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                ADDRR { bits }
            }
            #[doc = "Bit 15 - Enable 9-Bit Mode"]
            #[inline]
            pub fn _9biten(&self) -> _9BITENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                _9BITENR { bits }
            }
        }
        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 0:7 - Self Address for 9-Bit Mode"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
            #[doc = "Bit 15 - Enable 9-Bit Mode"]
            #[inline]
            pub fn _9biten(&mut self) -> __9BITENW {
                __9BITENW { w: self }
            }
        }
    }
    #[doc = "UART 9-Bit Self Address Mask"]
    pub struct _9BITAMASK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART 9-Bit Self Address Mask"]
    pub mod _9bitamask {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_9BITAMASK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASKR {
            bits: u8,
        }
        impl MASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Self Address Mask for 9-Bit Mode"]
            #[inline]
            pub fn mask(&self) -> MASKR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MASKR { bits }
            }
        }
        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 0:7 - Self Address Mask for 9-Bit Mode"]
            #[inline]
            pub fn mask(&mut self) -> _MASKW {
                _MASKW { w: self }
            }
        }
    }
    #[doc = "UART Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct SCR {
            bits: bool,
        }
        impl SCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NBR {
            bits: bool,
        }
        impl NBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSR {
            bits: bool,
        }
        impl MSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSER {
            bits: bool,
        }
        impl MSER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Smart Card Support"]
            #[inline]
            pub fn sc(&self) -> SCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SCR { bits }
            }
            #[doc = "Bit 1 - 9-Bit Support"]
            #[inline]
            pub fn nb(&self) -> NBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NBR { bits }
            }
            #[doc = "Bit 2 - Modem Support"]
            #[inline]
            pub fn ms(&self) -> MSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSR { bits }
            }
            #[doc = "Bit 3 - Modem Support Extended"]
            #[inline]
            pub fn mse(&self) -> MSER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSER { bits }
            }
        }
    }
    #[doc = "UART Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "UART Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CSR {
            #[doc = "System clock (based on clock source and divisor factor)"]
            SYSCLK,
            #[doc = "Alternate clock (as defined in System Control Module)"]
            ALTCLK,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CSR::SYSCLK => 0,
                    CSR::ALTCLK => 0x05,
                    CSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CSR {
                match value {
                    0 => CSR::SYSCLK,
                    5 => CSR::ALTCLK,
                    i => CSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSCLK`"]
            #[inline]
            pub fn is_sysclk(&self) -> bool {
                *self == CSR::SYSCLK
            }
            #[doc = "Checks if the value of the field is `ALTCLK`"]
            #[inline]
            pub fn is_altclk(&self) -> bool {
                *self == CSR::ALTCLK
            }
        }
        #[doc = "Values that can be written to the field `CS`"]
        pub enum CSW {
            #[doc = "System clock (based on clock source and divisor factor)"]
            SYSCLK,
            #[doc = "Alternate clock (as defined in System Control Module)"]
            ALTCLK,
        }
        impl CSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CSW::SYSCLK => 0,
                    CSW::ALTCLK => 5,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "System clock (based on clock source and divisor factor)"]
            #[inline]
            pub fn sysclk(self) -> &'a mut W {
                self.variant(CSW::SYSCLK)
            }
            #[doc = "Alternate clock (as defined in System Control Module)"]
            #[inline]
            pub fn altclk(self) -> &'a mut W {
                self.variant(CSW::ALTCLK)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - UART Baud Clock Source"]
            #[inline]
            pub fn cs(&self) -> CSR {
                CSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - UART Baud Clock Source"]
            #[inline]
            pub fn cs(&mut self) -> _CSW {
                _CSW { w: self }
            }
        }
    }
}
#[doc = "UART1"]
pub struct UART1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART1 {}
impl UART1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4000_d000 as *const _
    }
}
impl Deref for UART1 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART1::ptr() }
    }
}
#[doc = "UART2"]
pub struct UART2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART2 {}
impl UART2 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4000_e000 as *const _
    }
}
impl Deref for UART2 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART2::ptr() }
    }
}
#[doc = "UART3"]
pub struct UART3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART3 {}
impl UART3 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4000_f000 as *const _
    }
}
impl Deref for UART3 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART3::ptr() }
    }
}
#[doc = "UART4"]
pub struct UART4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART4 {}
impl UART4 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4001_0000 as *const _
    }
}
impl Deref for UART4 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART4::ptr() }
    }
}
#[doc = "UART5"]
pub struct UART5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART5 {}
impl UART5 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4001_1000 as *const _
    }
}
impl Deref for UART5 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART5::ptr() }
    }
}
#[doc = "UART6"]
pub struct UART6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART6 {}
impl UART6 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4001_2000 as *const _
    }
}
impl Deref for UART6 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART6::ptr() }
    }
}
#[doc = "UART7"]
pub struct UART7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UART7 {}
impl UART7 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const uart0::RegisterBlock {
        0x4001_3000 as *const _
    }
}
impl Deref for UART7 {
    type Target = uart0::RegisterBlock;
    fn deref(&self) -> &uart0::RegisterBlock {
        unsafe { &*UART7::ptr() }
    }
}
#[doc = "I2C register offsets"]
pub struct I2C0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C0 {}
impl I2C0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x4002_0000 as *const _
    }
}
impl Deref for I2C0 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C0::ptr() }
    }
}
#[doc = "I2C register offsets"]
pub mod i2c0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - I2C Master Slave Address"]
        pub msa: MSA,
        #[doc = "0x04 - I2C Master Control/Status"]
        pub mcs: MCS,
        #[doc = "0x08 - I2C Master Data"]
        pub mdr: MDR,
        #[doc = "0x0c - I2C Master Timer Period"]
        pub mtpr: MTPR,
        #[doc = "0x10 - I2C Master Interrupt Mask"]
        pub mimr: MIMR,
        #[doc = "0x14 - I2C Master Raw Interrupt Status"]
        pub mris: MRIS,
        #[doc = "0x18 - I2C Master Masked Interrupt Status"]
        pub mmis: MMIS,
        #[doc = "0x1c - I2C Master Interrupt Clear"]
        pub micr: MICR,
        #[doc = "0x20 - I2C Master Configuration"]
        pub mcr: MCR,
        #[doc = "0x24 - I2C Master Clock Low Timeout Count"]
        pub mclkocnt: MCLKOCNT,
        _reserved0: [u8; 4usize],
        #[doc = "0x2c - I2C Master Bus Monitor"]
        pub mbmon: MBMON,
        #[doc = "0x30 - I2C Master Burst Length"]
        pub mblen: MBLEN,
        #[doc = "0x34 - I2C Master Burst Count"]
        pub mbcnt: MBCNT,
        _reserved1: [u8; 1992usize],
        #[doc = "0x800 - I2C Slave Own Address"]
        pub soar: SOAR,
        #[doc = "0x804 - I2C Slave Control/Status"]
        pub scsr: SCSR,
        #[doc = "0x808 - I2C Slave Data"]
        pub sdr: SDR,
        #[doc = "0x80c - I2C Slave Interrupt Mask"]
        pub simr: SIMR,
        #[doc = "0x810 - I2C Slave Raw Interrupt Status"]
        pub sris: SRIS,
        #[doc = "0x814 - I2C Slave Masked Interrupt Status"]
        pub smis: SMIS,
        #[doc = "0x818 - I2C Slave Interrupt Clear"]
        pub sicr: SICR,
        #[doc = "0x81c - I2C Slave Own Address 2"]
        pub soar2: SOAR2,
        #[doc = "0x820 - I2C Slave ACK Control"]
        pub sackctl: SACKCTL,
        _reserved2: [u8; 1756usize],
        #[doc = "0xf00 - I2C FIFO Data"]
        pub fifodata: FIFODATA,
        #[doc = "0xf04 - I2C FIFO Control"]
        pub fifoctl: FIFOCTL,
        #[doc = "0xf08 - I2C FIFO Status"]
        pub fifostatus: FIFOSTATUS,
        _reserved3: [u8; 180usize],
        #[doc = "0xfc0 - I2C Peripheral Properties"]
        pub pp: PP,
        #[doc = "0xfc4 - I2C Peripheral Configuration"]
        pub pc: PC,
    }
    #[doc = "I2C Master Slave Address"]
    pub struct MSA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Slave Address"]
    pub mod msa {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MSA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSR {
            bits: bool,
        }
        impl RSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAR {
            bits: u8,
        }
        impl SAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Receive not send"]
            #[inline]
            pub fn rs(&self) -> RSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSR { bits }
            }
            #[doc = "Bits 1:7 - I2C Slave Address"]
            #[inline]
            pub fn sa(&self) -> SAR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SAR { bits }
            }
        }
        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 = "Bit 0 - Receive not send"]
            #[inline]
            pub fn rs(&mut self) -> _RSW {
                _RSW { w: self }
            }
            #[doc = "Bits 1:7 - I2C Slave Address"]
            #[inline]
            pub fn sa(&mut self) -> _SAW {
                _SAW { w: self }
            }
        }
    }
    #[doc = "I2C Master Control/Status"]
    pub struct MCS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Control/Status"]
    pub mod mcs {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MCS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RUNR {
            bits: bool,
        }
        impl RUNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSYR {
            bits: bool,
        }
        impl BUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTR {
            bits: bool,
        }
        impl STARTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADRACKR {
            bits: bool,
        }
        impl ADRACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPR {
            bits: bool,
        }
        impl STOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACKR {
            bits: bool,
        }
        impl ACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATACKR {
            bits: bool,
        }
        impl DATACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBLSTR {
            bits: bool,
        }
        impl ARBLSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSR {
            bits: bool,
        }
        impl HSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDLER {
            bits: bool,
        }
        impl IDLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct QCMDR {
            bits: bool,
        }
        impl QCMDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BURSTR {
            bits: bool,
        }
        impl BURSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSBSYR {
            bits: bool,
        }
        impl BUSBSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKTOR {
            bits: bool,
        }
        impl CLKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACTDMATXR {
            bits: bool,
        }
        impl ACTDMATXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACTDMARXR {
            bits: bool,
        }
        impl ACTDMARXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RUNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RUNW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _BUSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BUSYW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STARTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STARTW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADRACKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADRACKW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STOPW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACKW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATACKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATACKW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ARBLSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ARBLSTW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDLEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _QCMDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _QCMDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BURSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BURSTW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BUSBSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BUSBSYW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKTOW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTDMATXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTDMATXW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTDMARXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTDMARXW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Master Enable"]
            #[inline]
            pub fn run(&self) -> RUNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RUNR { bits }
            }
            #[doc = "Bit 0 - I2C Busy"]
            #[inline]
            pub fn busy(&self) -> BUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSYR { bits }
            }
            #[doc = "Bit 1 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 1 - Generate START"]
            #[inline]
            pub fn start(&self) -> STARTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTR { bits }
            }
            #[doc = "Bit 2 - Acknowledge Address"]
            #[inline]
            pub fn adrack(&self) -> ADRACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADRACKR { bits }
            }
            #[doc = "Bit 2 - Generate STOP"]
            #[inline]
            pub fn stop(&self) -> STOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPR { bits }
            }
            #[doc = "Bit 3 - Data Acknowledge Enable"]
            #[inline]
            pub fn ack(&self) -> ACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACKR { bits }
            }
            #[doc = "Bit 3 - Acknowledge Data"]
            #[inline]
            pub fn datack(&self) -> DATACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATACKR { bits }
            }
            #[doc = "Bit 4 - Arbitration Lost"]
            #[inline]
            pub fn arblst(&self) -> ARBLSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBLSTR { bits }
            }
            #[doc = "Bit 4 - High-Speed Enable"]
            #[inline]
            pub fn hs(&self) -> HSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSR { bits }
            }
            #[doc = "Bit 5 - I2C Idle"]
            #[inline]
            pub fn idle(&self) -> IDLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IDLER { bits }
            }
            #[doc = "Bit 5 - Quick Command"]
            #[inline]
            pub fn qcmd(&self) -> QCMDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                QCMDR { bits }
            }
            #[doc = "Bit 6 - Burst Enable"]
            #[inline]
            pub fn burst(&self) -> BURSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BURSTR { bits }
            }
            #[doc = "Bit 6 - Bus Busy"]
            #[inline]
            pub fn busbsy(&self) -> BUSBSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSBSYR { bits }
            }
            #[doc = "Bit 7 - Clock Timeout Error"]
            #[inline]
            pub fn clkto(&self) -> CLKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKTOR { bits }
            }
            #[doc = "Bit 30 - DMA TX Active Status"]
            #[inline]
            pub fn actdmatx(&self) -> ACTDMATXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACTDMATXR { bits }
            }
            #[doc = "Bit 31 - DMA RX Active Status"]
            #[inline]
            pub fn actdmarx(&self) -> ACTDMARXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACTDMARXR { bits }
            }
        }
        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 = "Bit 0 - I2C Master Enable"]
            #[inline]
            pub fn run(&mut self) -> _RUNW {
                _RUNW { w: self }
            }
            #[doc = "Bit 0 - I2C Busy"]
            #[inline]
            pub fn busy(&mut self) -> _BUSYW {
                _BUSYW { w: self }
            }
            #[doc = "Bit 1 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 1 - Generate START"]
            #[inline]
            pub fn start(&mut self) -> _STARTW {
                _STARTW { w: self }
            }
            #[doc = "Bit 2 - Acknowledge Address"]
            #[inline]
            pub fn adrack(&mut self) -> _ADRACKW {
                _ADRACKW { w: self }
            }
            #[doc = "Bit 2 - Generate STOP"]
            #[inline]
            pub fn stop(&mut self) -> _STOPW {
                _STOPW { w: self }
            }
            #[doc = "Bit 3 - Data Acknowledge Enable"]
            #[inline]
            pub fn ack(&mut self) -> _ACKW {
                _ACKW { w: self }
            }
            #[doc = "Bit 3 - Acknowledge Data"]
            #[inline]
            pub fn datack(&mut self) -> _DATACKW {
                _DATACKW { w: self }
            }
            #[doc = "Bit 4 - Arbitration Lost"]
            #[inline]
            pub fn arblst(&mut self) -> _ARBLSTW {
                _ARBLSTW { w: self }
            }
            #[doc = "Bit 4 - High-Speed Enable"]
            #[inline]
            pub fn hs(&mut self) -> _HSW {
                _HSW { w: self }
            }
            #[doc = "Bit 5 - I2C Idle"]
            #[inline]
            pub fn idle(&mut self) -> _IDLEW {
                _IDLEW { w: self }
            }
            #[doc = "Bit 5 - Quick Command"]
            #[inline]
            pub fn qcmd(&mut self) -> _QCMDW {
                _QCMDW { w: self }
            }
            #[doc = "Bit 6 - Burst Enable"]
            #[inline]
            pub fn burst(&mut self) -> _BURSTW {
                _BURSTW { w: self }
            }
            #[doc = "Bit 6 - Bus Busy"]
            #[inline]
            pub fn busbsy(&mut self) -> _BUSBSYW {
                _BUSBSYW { w: self }
            }
            #[doc = "Bit 7 - Clock Timeout Error"]
            #[inline]
            pub fn clkto(&mut self) -> _CLKTOW {
                _CLKTOW { w: self }
            }
            #[doc = "Bit 30 - DMA TX Active Status"]
            #[inline]
            pub fn actdmatx(&mut self) -> _ACTDMATXW {
                _ACTDMATXW { w: self }
            }
            #[doc = "Bit 31 - DMA RX Active Status"]
            #[inline]
            pub fn actdmarx(&mut self) -> _ACTDMARXW {
                _ACTDMARXW { w: self }
            }
        }
    }
    #[doc = "I2C Master Data"]
    pub struct MDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Data"]
    pub mod mdr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - This byte contains the data transferred during a transaction"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
        }
        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 0:7 - This byte contains the data transferred during a transaction"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "I2C Master Timer Period"]
    pub struct MTPR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Timer Period"]
    pub mod mtpr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MTPR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPRR {
            bits: u8,
        }
        impl TPRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSR {
            bits: bool,
        }
        impl HSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PULSEL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PULSELR {
            #[doc = "Bypass"]
            BYPASS,
            #[doc = "1 clock"]
            _1,
            #[doc = "2 clocks"]
            _2,
            #[doc = "3 clocks"]
            _3,
            #[doc = "4 clocks"]
            _4,
            #[doc = "8 clocks"]
            _8,
            #[doc = "16 clocks"]
            _16,
            #[doc = "31 clocks"]
            _31,
        }
        impl PULSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PULSELR::BYPASS => 0,
                    PULSELR::_1 => 0x01,
                    PULSELR::_2 => 0x02,
                    PULSELR::_3 => 0x03,
                    PULSELR::_4 => 0x04,
                    PULSELR::_8 => 0x05,
                    PULSELR::_16 => 0x06,
                    PULSELR::_31 => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PULSELR {
                match value {
                    0 => PULSELR::BYPASS,
                    1 => PULSELR::_1,
                    2 => PULSELR::_2,
                    3 => PULSELR::_3,
                    4 => PULSELR::_4,
                    5 => PULSELR::_8,
                    6 => PULSELR::_16,
                    7 => PULSELR::_31,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `BYPASS`"]
            #[inline]
            pub fn is_bypass(&self) -> bool {
                *self == PULSELR::BYPASS
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == PULSELR::_1
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == PULSELR::_2
            }
            #[doc = "Checks if the value of the field is `_3`"]
            #[inline]
            pub fn is_3(&self) -> bool {
                *self == PULSELR::_3
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == PULSELR::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == PULSELR::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == PULSELR::_16
            }
            #[doc = "Checks if the value of the field is `_31`"]
            #[inline]
            pub fn is_31(&self) -> bool {
                *self == PULSELR::_31
            }
        }
        #[doc = r" Proxy"]
        pub struct _TPRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TPRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PULSEL`"]
        pub enum PULSELW {
            #[doc = "Bypass"]
            BYPASS,
            #[doc = "1 clock"]
            _1,
            #[doc = "2 clocks"]
            _2,
            #[doc = "3 clocks"]
            _3,
            #[doc = "4 clocks"]
            _4,
            #[doc = "8 clocks"]
            _8,
            #[doc = "16 clocks"]
            _16,
            #[doc = "31 clocks"]
            _31,
        }
        impl PULSELW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PULSELW::BYPASS => 0,
                    PULSELW::_1 => 1,
                    PULSELW::_2 => 2,
                    PULSELW::_3 => 3,
                    PULSELW::_4 => 4,
                    PULSELW::_8 => 5,
                    PULSELW::_16 => 6,
                    PULSELW::_31 => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PULSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PULSELW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PULSELW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bypass"]
            #[inline]
            pub fn bypass(self) -> &'a mut W {
                self.variant(PULSELW::BYPASS)
            }
            #[doc = "1 clock"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(PULSELW::_1)
            }
            #[doc = "2 clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(PULSELW::_2)
            }
            #[doc = "3 clocks"]
            #[inline]
            pub fn _3(self) -> &'a mut W {
                self.variant(PULSELW::_3)
            }
            #[doc = "4 clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(PULSELW::_4)
            }
            #[doc = "8 clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(PULSELW::_8)
            }
            #[doc = "16 clocks"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(PULSELW::_16)
            }
            #[doc = "31 clocks"]
            #[inline]
            pub fn _31(self) -> &'a mut W {
                self.variant(PULSELW::_31)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:6 - Timer Period"]
            #[inline]
            pub fn tpr(&self) -> TPRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TPRR { bits }
            }
            #[doc = "Bit 7 - High-Speed Enable"]
            #[inline]
            pub fn hs(&self) -> HSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSR { bits }
            }
            #[doc = "Bits 16:18 - Glitch Suppression Pulse Width"]
            #[inline]
            pub fn pulsel(&self) -> PULSELR {
                PULSELR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:6 - Timer Period"]
            #[inline]
            pub fn tpr(&mut self) -> _TPRW {
                _TPRW { w: self }
            }
            #[doc = "Bit 7 - High-Speed Enable"]
            #[inline]
            pub fn hs(&mut self) -> _HSW {
                _HSW { w: self }
            }
            #[doc = "Bits 16:18 - Glitch Suppression Pulse Width"]
            #[inline]
            pub fn pulsel(&mut self) -> _PULSELW {
                _PULSELW { w: self }
            }
        }
    }
    #[doc = "I2C Master Interrupt Mask"]
    pub struct MIMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Interrupt Mask"]
    pub mod mimr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MIMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IMR {
            bits: bool,
        }
        impl IMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKIMR {
            bits: bool,
        }
        impl CLKIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXIMR {
            bits: bool,
        }
        impl DMARXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXIMR {
            bits: bool,
        }
        impl DMATXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NACKIMR {
            bits: bool,
        }
        impl NACKIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTIMR {
            bits: bool,
        }
        impl STARTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPIMR {
            bits: bool,
        }
        impl STOPIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBLOSTIMR {
            bits: bool,
        }
        impl ARBLOSTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIMR {
            bits: bool,
        }
        impl TXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIMR {
            bits: bool,
        }
        impl RXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFEIMR {
            bits: bool,
        }
        impl TXFEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFIMR {
            bits: bool,
        }
        impl RXFFIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NACKIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NACKIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STARTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STARTIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STOPIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STOPIMW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ARBLOSTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ARBLOSTIMW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIMW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXFEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXFEIMW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXFFIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXFFIMW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Master Interrupt Mask"]
            #[inline]
            pub fn im(&self) -> IMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IMR { bits }
            }
            #[doc = "Bit 1 - Clock Timeout Interrupt Mask"]
            #[inline]
            pub fn clkim(&self) -> CLKIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKIMR { bits }
            }
            #[doc = "Bit 2 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&self) -> DMARXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXIMR { bits }
            }
            #[doc = "Bit 3 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&self) -> DMATXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXIMR { bits }
            }
            #[doc = "Bit 4 - Address/Data NACK Interrupt Mask"]
            #[inline]
            pub fn nackim(&self) -> NACKIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NACKIMR { bits }
            }
            #[doc = "Bit 5 - START Detection Interrupt Mask"]
            #[inline]
            pub fn startim(&self) -> STARTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTIMR { bits }
            }
            #[doc = "Bit 6 - STOP Detection Interrupt Mask"]
            #[inline]
            pub fn stopim(&self) -> STOPIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPIMR { bits }
            }
            #[doc = "Bit 7 - Arbitration Lost Interrupt Mask"]
            #[inline]
            pub fn arblostim(&self) -> ARBLOSTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBLOSTIMR { bits }
            }
            #[doc = "Bit 8 - Transmit FIFO Request Interrupt Mask"]
            #[inline]
            pub fn txim(&self) -> TXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIMR { bits }
            }
            #[doc = "Bit 9 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxim(&self) -> RXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIMR { bits }
            }
            #[doc = "Bit 10 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfeim(&self) -> TXFEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFEIMR { bits }
            }
            #[doc = "Bit 11 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffim(&self) -> RXFFIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFIMR { bits }
            }
        }
        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 = "Bit 0 - Master Interrupt Mask"]
            #[inline]
            pub fn im(&mut self) -> _IMW {
                _IMW { w: self }
            }
            #[doc = "Bit 1 - Clock Timeout Interrupt Mask"]
            #[inline]
            pub fn clkim(&mut self) -> _CLKIMW {
                _CLKIMW { w: self }
            }
            #[doc = "Bit 2 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&mut self) -> _DMARXIMW {
                _DMARXIMW { w: self }
            }
            #[doc = "Bit 3 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&mut self) -> _DMATXIMW {
                _DMATXIMW { w: self }
            }
            #[doc = "Bit 4 - Address/Data NACK Interrupt Mask"]
            #[inline]
            pub fn nackim(&mut self) -> _NACKIMW {
                _NACKIMW { w: self }
            }
            #[doc = "Bit 5 - START Detection Interrupt Mask"]
            #[inline]
            pub fn startim(&mut self) -> _STARTIMW {
                _STARTIMW { w: self }
            }
            #[doc = "Bit 6 - STOP Detection Interrupt Mask"]
            #[inline]
            pub fn stopim(&mut self) -> _STOPIMW {
                _STOPIMW { w: self }
            }
            #[doc = "Bit 7 - Arbitration Lost Interrupt Mask"]
            #[inline]
            pub fn arblostim(&mut self) -> _ARBLOSTIMW {
                _ARBLOSTIMW { w: self }
            }
            #[doc = "Bit 8 - Transmit FIFO Request Interrupt Mask"]
            #[inline]
            pub fn txim(&mut self) -> _TXIMW {
                _TXIMW { w: self }
            }
            #[doc = "Bit 9 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxim(&mut self) -> _RXIMW {
                _RXIMW { w: self }
            }
            #[doc = "Bit 10 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfeim(&mut self) -> _TXFEIMW {
                _TXFEIMW { w: self }
            }
            #[doc = "Bit 11 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffim(&mut self) -> _RXFFIMW {
                _RXFFIMW { w: self }
            }
        }
    }
    #[doc = "I2C Master Raw Interrupt Status"]
    pub struct MRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Raw Interrupt Status"]
    pub mod mris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RISR {
            bits: bool,
        }
        impl RISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKRISR {
            bits: bool,
        }
        impl CLKRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXRISR {
            bits: bool,
        }
        impl DMARXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXRISR {
            bits: bool,
        }
        impl DMATXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NACKRISR {
            bits: bool,
        }
        impl NACKRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTRISR {
            bits: bool,
        }
        impl STARTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPRISR {
            bits: bool,
        }
        impl STOPRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBLOSTRISR {
            bits: bool,
        }
        impl ARBLOSTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRISR {
            bits: bool,
        }
        impl TXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRISR {
            bits: bool,
        }
        impl RXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFERISR {
            bits: bool,
        }
        impl TXFERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFRISR {
            bits: bool,
        }
        impl RXFFRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Master Raw Interrupt Status"]
            #[inline]
            pub fn ris(&self) -> RISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RISR { bits }
            }
            #[doc = "Bit 1 - Clock Timeout Raw Interrupt Status"]
            #[inline]
            pub fn clkris(&self) -> CLKRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKRISR { bits }
            }
            #[doc = "Bit 2 - Receive DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmarxris(&self) -> DMARXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXRISR { bits }
            }
            #[doc = "Bit 3 - Transmit DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmatxris(&self) -> DMATXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXRISR { bits }
            }
            #[doc = "Bit 4 - Address/Data NACK Raw Interrupt Status"]
            #[inline]
            pub fn nackris(&self) -> NACKRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NACKRISR { bits }
            }
            #[doc = "Bit 5 - START Detection Raw Interrupt Status"]
            #[inline]
            pub fn startris(&self) -> STARTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTRISR { bits }
            }
            #[doc = "Bit 6 - STOP Detection Raw Interrupt Status"]
            #[inline]
            pub fn stopris(&self) -> STOPRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPRISR { bits }
            }
            #[doc = "Bit 7 - Arbitration Lost Raw Interrupt Status"]
            #[inline]
            pub fn arblostris(&self) -> ARBLOSTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBLOSTRISR { bits }
            }
            #[doc = "Bit 8 - Transmit Request Raw Interrupt Status"]
            #[inline]
            pub fn txris(&self) -> TXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRISR { bits }
            }
            #[doc = "Bit 9 - Receive FIFO Request Raw Interrupt Status"]
            #[inline]
            pub fn rxris(&self) -> RXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXRISR { bits }
            }
            #[doc = "Bit 10 - Transmit FIFO Empty Raw Interrupt Status"]
            #[inline]
            pub fn txferis(&self) -> TXFERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFERISR { bits }
            }
            #[doc = "Bit 11 - Receive FIFO Full Raw Interrupt Status"]
            #[inline]
            pub fn rxffris(&self) -> RXFFRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFRISR { bits }
            }
        }
    }
    #[doc = "I2C Master Masked Interrupt Status"]
    pub struct MMIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Masked Interrupt Status"]
    pub mod mmis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MMIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct MISR {
            bits: bool,
        }
        impl MISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKMISR {
            bits: bool,
        }
        impl CLKMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXMISR {
            bits: bool,
        }
        impl DMARXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXMISR {
            bits: bool,
        }
        impl DMATXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NACKMISR {
            bits: bool,
        }
        impl NACKMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTMISR {
            bits: bool,
        }
        impl STARTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPMISR {
            bits: bool,
        }
        impl STOPMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBLOSTMISR {
            bits: bool,
        }
        impl ARBLOSTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXMISR {
            bits: bool,
        }
        impl TXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXMISR {
            bits: bool,
        }
        impl RXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFEMISR {
            bits: bool,
        }
        impl TXFEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFMISR {
            bits: bool,
        }
        impl RXFFMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Masked Interrupt Status"]
            #[inline]
            pub fn mis(&self) -> MISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MISR { bits }
            }
            #[doc = "Bit 1 - Clock Timeout Masked Interrupt Status"]
            #[inline]
            pub fn clkmis(&self) -> CLKMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKMISR { bits }
            }
            #[doc = "Bit 2 - Receive DMA Interrupt Status"]
            #[inline]
            pub fn dmarxmis(&self) -> DMARXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXMISR { bits }
            }
            #[doc = "Bit 3 - Transmit DMA Interrupt Status"]
            #[inline]
            pub fn dmatxmis(&self) -> DMATXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXMISR { bits }
            }
            #[doc = "Bit 4 - Address/Data NACK Interrupt Mask"]
            #[inline]
            pub fn nackmis(&self) -> NACKMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NACKMISR { bits }
            }
            #[doc = "Bit 5 - START Detection Interrupt Mask"]
            #[inline]
            pub fn startmis(&self) -> STARTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTMISR { bits }
            }
            #[doc = "Bit 6 - STOP Detection Interrupt Mask"]
            #[inline]
            pub fn stopmis(&self) -> STOPMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPMISR { bits }
            }
            #[doc = "Bit 7 - Arbitration Lost Interrupt Mask"]
            #[inline]
            pub fn arblostmis(&self) -> ARBLOSTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBLOSTMISR { bits }
            }
            #[doc = "Bit 8 - Transmit Request Interrupt Mask"]
            #[inline]
            pub fn txmis(&self) -> TXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXMISR { bits }
            }
            #[doc = "Bit 9 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxmis(&self) -> RXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXMISR { bits }
            }
            #[doc = "Bit 10 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfemis(&self) -> TXFEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFEMISR { bits }
            }
            #[doc = "Bit 11 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffmis(&self) -> RXFFMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFMISR { bits }
            }
        }
    }
    #[doc = "I2C Master Interrupt Clear"]
    pub struct MICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Interrupt Clear"]
    pub mod micr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MICR {
            #[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 _ICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ICW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKICW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXICW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXICW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NACKICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NACKICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STARTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STARTICW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STOPICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STOPICW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ARBLOSTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ARBLOSTICW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXICW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXICW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXFEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXFEICW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXFFICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXFFICW<'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 = 11;
                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 = "Bit 0 - Master Interrupt Clear"]
            #[inline]
            pub fn ic(&mut self) -> _ICW {
                _ICW { w: self }
            }
            #[doc = "Bit 1 - Clock Timeout Interrupt Clear"]
            #[inline]
            pub fn clkic(&mut self) -> _CLKICW {
                _CLKICW { w: self }
            }
            #[doc = "Bit 2 - Receive DMA Interrupt Clear"]
            #[inline]
            pub fn dmarxic(&mut self) -> _DMARXICW {
                _DMARXICW { w: self }
            }
            #[doc = "Bit 3 - Transmit DMA Interrupt Clear"]
            #[inline]
            pub fn dmatxic(&mut self) -> _DMATXICW {
                _DMATXICW { w: self }
            }
            #[doc = "Bit 4 - Address/Data NACK Interrupt Clear"]
            #[inline]
            pub fn nackic(&mut self) -> _NACKICW {
                _NACKICW { w: self }
            }
            #[doc = "Bit 5 - START Detection Interrupt Clear"]
            #[inline]
            pub fn startic(&mut self) -> _STARTICW {
                _STARTICW { w: self }
            }
            #[doc = "Bit 6 - STOP Detection Interrupt Clear"]
            #[inline]
            pub fn stopic(&mut self) -> _STOPICW {
                _STOPICW { w: self }
            }
            #[doc = "Bit 7 - Arbitration Lost Interrupt Clear"]
            #[inline]
            pub fn arblostic(&mut self) -> _ARBLOSTICW {
                _ARBLOSTICW { w: self }
            }
            #[doc = "Bit 8 - Transmit FIFO Request Interrupt Clear"]
            #[inline]
            pub fn txic(&mut self) -> _TXICW {
                _TXICW { w: self }
            }
            #[doc = "Bit 9 - Receive FIFO Request Interrupt Clear"]
            #[inline]
            pub fn rxic(&mut self) -> _RXICW {
                _RXICW { w: self }
            }
            #[doc = "Bit 10 - Transmit FIFO Empty Interrupt Clear"]
            #[inline]
            pub fn txfeic(&mut self) -> _TXFEICW {
                _TXFEICW { w: self }
            }
            #[doc = "Bit 11 - Receive FIFO Full Interrupt Clear"]
            #[inline]
            pub fn rxffic(&mut self) -> _RXFFICW {
                _RXFFICW { w: self }
            }
        }
    }
    #[doc = "I2C Master Configuration"]
    pub struct MCR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Configuration"]
    pub mod mcr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MCR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LPBKR {
            bits: bool,
        }
        impl LPBKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MFER {
            bits: bool,
        }
        impl MFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SFER {
            bits: bool,
        }
        impl SFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _LPBKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LPBKW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MFEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SFEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Loopback"]
            #[inline]
            pub fn lpbk(&self) -> LPBKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LPBKR { bits }
            }
            #[doc = "Bit 4 - I2C Master Function Enable"]
            #[inline]
            pub fn mfe(&self) -> MFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MFER { bits }
            }
            #[doc = "Bit 5 - I2C Slave Function Enable"]
            #[inline]
            pub fn sfe(&self) -> SFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SFER { bits }
            }
        }
        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 = "Bit 0 - I2C Loopback"]
            #[inline]
            pub fn lpbk(&mut self) -> _LPBKW {
                _LPBKW { w: self }
            }
            #[doc = "Bit 4 - I2C Master Function Enable"]
            #[inline]
            pub fn mfe(&mut self) -> _MFEW {
                _MFEW { w: self }
            }
            #[doc = "Bit 5 - I2C Slave Function Enable"]
            #[inline]
            pub fn sfe(&mut self) -> _SFEW {
                _SFEW { w: self }
            }
        }
    }
    #[doc = "I2C Master Clock Low Timeout Count"]
    pub struct MCLKOCNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Clock Low Timeout Count"]
    pub mod mclkocnt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MCLKOCNT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTLR {
            bits: u8,
        }
        impl CNTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - I2C Master Count"]
            #[inline]
            pub fn cntl(&self) -> CNTLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CNTLR { bits }
            }
        }
        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 0:7 - I2C Master Count"]
            #[inline]
            pub fn cntl(&mut self) -> _CNTLW {
                _CNTLW { w: self }
            }
        }
    }
    #[doc = "I2C Master Bus Monitor"]
    pub struct MBMON {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Bus Monitor"]
    pub mod mbmon {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MBMON {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct SCLR {
            bits: bool,
        }
        impl SCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SDAR {
            bits: bool,
        }
        impl SDAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C SCL Status"]
            #[inline]
            pub fn scl(&self) -> SCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SCLR { bits }
            }
            #[doc = "Bit 1 - I2C SDA Status"]
            #[inline]
            pub fn sda(&self) -> SDAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SDAR { bits }
            }
        }
    }
    #[doc = "I2C Master Burst Length"]
    pub struct MBLEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Burst Length"]
    pub mod mblen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MBLEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTLR {
            bits: u8,
        }
        impl CNTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - I2C Burst Length"]
            #[inline]
            pub fn cntl(&self) -> CNTLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CNTLR { bits }
            }
        }
        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 0:7 - I2C Burst Length"]
            #[inline]
            pub fn cntl(&mut self) -> _CNTLW {
                _CNTLW { w: self }
            }
        }
    }
    #[doc = "I2C Master Burst Count"]
    pub struct MBCNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Master Burst Count"]
    pub mod mbcnt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MBCNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTLR {
            bits: u8,
        }
        impl CNTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - I2C Master Burst Count"]
            #[inline]
            pub fn cntl(&self) -> CNTLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CNTLR { bits }
            }
        }
    }
    #[doc = "I2C Slave Own Address"]
    pub struct SOAR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Own Address"]
    pub mod soar {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SOAR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct OARR {
            bits: u8,
        }
        impl OARR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _OARW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OARW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:6 - I2C Slave Own Address"]
            #[inline]
            pub fn oar(&self) -> OARR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                OARR { bits }
            }
        }
        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 0:6 - I2C Slave Own Address"]
            #[inline]
            pub fn oar(&mut self) -> _OARW {
                _OARW { w: self }
            }
        }
    }
    #[doc = "I2C Slave Control/Status"]
    pub struct SCSR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Control/Status"]
    pub mod scsr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SCSR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DAR {
            bits: bool,
        }
        impl DAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RREQR {
            bits: bool,
        }
        impl RREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFIFOR {
            bits: bool,
        }
        impl TXFIFOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TREQR {
            bits: bool,
        }
        impl TREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FBRR {
            bits: bool,
        }
        impl FBRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFIFOR {
            bits: bool,
        }
        impl RXFIFOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OAR2SELR {
            bits: bool,
        }
        impl OAR2SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct QCMDSTR {
            bits: bool,
        }
        impl QCMDSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct QCMDRWR {
            bits: bool,
        }
        impl QCMDRWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACTDMATXR {
            bits: bool,
        }
        impl ACTDMATXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACTDMARXR {
            bits: bool,
        }
        impl ACTDMARXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Device Active"]
            #[inline]
            pub fn da(&self) -> DAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DAR { bits }
            }
            #[doc = "Bit 0 - Receive Request"]
            #[inline]
            pub fn rreq(&self) -> RREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RREQR { bits }
            }
            #[doc = "Bit 1 - TX FIFO Enable"]
            #[inline]
            pub fn txfifo(&self) -> TXFIFOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFIFOR { bits }
            }
            #[doc = "Bit 1 - Transmit Request"]
            #[inline]
            pub fn treq(&self) -> TREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TREQR { bits }
            }
            #[doc = "Bit 2 - First Byte Received"]
            #[inline]
            pub fn fbr(&self) -> FBRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FBRR { bits }
            }
            #[doc = "Bit 2 - RX FIFO Enable"]
            #[inline]
            pub fn rxfifo(&self) -> RXFIFOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFIFOR { bits }
            }
            #[doc = "Bit 3 - OAR2 Address Matched"]
            #[inline]
            pub fn oar2sel(&self) -> OAR2SELR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OAR2SELR { bits }
            }
            #[doc = "Bit 4 - Quick Command Status"]
            #[inline]
            pub fn qcmdst(&self) -> QCMDSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                QCMDSTR { bits }
            }
            #[doc = "Bit 5 - Quick Command Read / Write"]
            #[inline]
            pub fn qcmdrw(&self) -> QCMDRWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                QCMDRWR { bits }
            }
            #[doc = "Bit 30 - DMA TX Active Status"]
            #[inline]
            pub fn actdmatx(&self) -> ACTDMATXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACTDMATXR { bits }
            }
            #[doc = "Bit 31 - DMA RX Active Status"]
            #[inline]
            pub fn actdmarx(&self) -> ACTDMARXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACTDMARXR { bits }
            }
        }
    }
    #[doc = "I2C Slave Data"]
    pub struct SDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Data"]
    pub mod sdr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Data for Transfer"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
        }
        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 0:7 - Data for Transfer"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "I2C Slave Interrupt Mask"]
    pub struct SIMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Interrupt Mask"]
    pub mod simr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SIMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAIMR {
            bits: bool,
        }
        impl DATAIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTIMR {
            bits: bool,
        }
        impl STARTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPIMR {
            bits: bool,
        }
        impl STOPIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXIMR {
            bits: bool,
        }
        impl DMARXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXIMR {
            bits: bool,
        }
        impl DMATXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIMR {
            bits: bool,
        }
        impl TXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIMR {
            bits: bool,
        }
        impl RXIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFEIMR {
            bits: bool,
        }
        impl TXFEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFIMR {
            bits: bool,
        }
        impl RXFFIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _STARTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STARTIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STOPIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STOPIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIMW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXFEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXFEIMW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXFFIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXFFIMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Data Interrupt Mask"]
            #[inline]
            pub fn dataim(&self) -> DATAIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATAIMR { bits }
            }
            #[doc = "Bit 1 - Start Condition Interrupt Mask"]
            #[inline]
            pub fn startim(&self) -> STARTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTIMR { bits }
            }
            #[doc = "Bit 2 - Stop Condition Interrupt Mask"]
            #[inline]
            pub fn stopim(&self) -> STOPIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPIMR { bits }
            }
            #[doc = "Bit 3 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&self) -> DMARXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXIMR { bits }
            }
            #[doc = "Bit 4 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&self) -> DMATXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXIMR { bits }
            }
            #[doc = "Bit 5 - Transmit FIFO Request Interrupt Mask"]
            #[inline]
            pub fn txim(&self) -> TXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIMR { bits }
            }
            #[doc = "Bit 6 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxim(&self) -> RXIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIMR { bits }
            }
            #[doc = "Bit 7 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfeim(&self) -> TXFEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFEIMR { bits }
            }
            #[doc = "Bit 8 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffim(&self) -> RXFFIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFIMR { bits }
            }
        }
        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 = "Bit 0 - Data Interrupt Mask"]
            #[inline]
            pub fn dataim(&mut self) -> _DATAIMW {
                _DATAIMW { w: self }
            }
            #[doc = "Bit 1 - Start Condition Interrupt Mask"]
            #[inline]
            pub fn startim(&mut self) -> _STARTIMW {
                _STARTIMW { w: self }
            }
            #[doc = "Bit 2 - Stop Condition Interrupt Mask"]
            #[inline]
            pub fn stopim(&mut self) -> _STOPIMW {
                _STOPIMW { w: self }
            }
            #[doc = "Bit 3 - Receive DMA Interrupt Mask"]
            #[inline]
            pub fn dmarxim(&mut self) -> _DMARXIMW {
                _DMARXIMW { w: self }
            }
            #[doc = "Bit 4 - Transmit DMA Interrupt Mask"]
            #[inline]
            pub fn dmatxim(&mut self) -> _DMATXIMW {
                _DMATXIMW { w: self }
            }
            #[doc = "Bit 5 - Transmit FIFO Request Interrupt Mask"]
            #[inline]
            pub fn txim(&mut self) -> _TXIMW {
                _TXIMW { w: self }
            }
            #[doc = "Bit 6 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxim(&mut self) -> _RXIMW {
                _RXIMW { w: self }
            }
            #[doc = "Bit 7 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfeim(&mut self) -> _TXFEIMW {
                _TXFEIMW { w: self }
            }
            #[doc = "Bit 8 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffim(&mut self) -> _RXFFIMW {
                _RXFFIMW { w: self }
            }
        }
    }
    #[doc = "I2C Slave Raw Interrupt Status"]
    pub struct SRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Raw Interrupt Status"]
    pub mod sris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATARISR {
            bits: bool,
        }
        impl DATARISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTRISR {
            bits: bool,
        }
        impl STARTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPRISR {
            bits: bool,
        }
        impl STOPRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXRISR {
            bits: bool,
        }
        impl DMARXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXRISR {
            bits: bool,
        }
        impl DMATXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRISR {
            bits: bool,
        }
        impl TXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRISR {
            bits: bool,
        }
        impl RXRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFERISR {
            bits: bool,
        }
        impl TXFERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFRISR {
            bits: bool,
        }
        impl RXFFRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Data Raw Interrupt Status"]
            #[inline]
            pub fn dataris(&self) -> DATARISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATARISR { bits }
            }
            #[doc = "Bit 1 - Start Condition Raw Interrupt Status"]
            #[inline]
            pub fn startris(&self) -> STARTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTRISR { bits }
            }
            #[doc = "Bit 2 - Stop Condition Raw Interrupt Status"]
            #[inline]
            pub fn stopris(&self) -> STOPRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPRISR { bits }
            }
            #[doc = "Bit 3 - Receive DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmarxris(&self) -> DMARXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXRISR { bits }
            }
            #[doc = "Bit 4 - Transmit DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmatxris(&self) -> DMATXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXRISR { bits }
            }
            #[doc = "Bit 5 - Transmit Request Raw Interrupt Status"]
            #[inline]
            pub fn txris(&self) -> TXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRISR { bits }
            }
            #[doc = "Bit 6 - Receive FIFO Request Raw Interrupt Status"]
            #[inline]
            pub fn rxris(&self) -> RXRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXRISR { bits }
            }
            #[doc = "Bit 7 - Transmit FIFO Empty Raw Interrupt Status"]
            #[inline]
            pub fn txferis(&self) -> TXFERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFERISR { bits }
            }
            #[doc = "Bit 8 - Receive FIFO Full Raw Interrupt Status"]
            #[inline]
            pub fn rxffris(&self) -> RXFFRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFRISR { bits }
            }
        }
    }
    #[doc = "I2C Slave Masked Interrupt Status"]
    pub struct SMIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Masked Interrupt Status"]
    pub mod smis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SMIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAMISR {
            bits: bool,
        }
        impl DATAMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STARTMISR {
            bits: bool,
        }
        impl STARTMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STOPMISR {
            bits: bool,
        }
        impl STOPMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXMISR {
            bits: bool,
        }
        impl DMARXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXMISR {
            bits: bool,
        }
        impl DMATXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXMISR {
            bits: bool,
        }
        impl TXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXMISR {
            bits: bool,
        }
        impl RXMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFEMISR {
            bits: bool,
        }
        impl TXFEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFMISR {
            bits: bool,
        }
        impl RXFFMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Data Masked Interrupt Status"]
            #[inline]
            pub fn datamis(&self) -> DATAMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATAMISR { bits }
            }
            #[doc = "Bit 1 - Start Condition Masked Interrupt Status"]
            #[inline]
            pub fn startmis(&self) -> STARTMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STARTMISR { bits }
            }
            #[doc = "Bit 2 - Stop Condition Masked Interrupt Status"]
            #[inline]
            pub fn stopmis(&self) -> STOPMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STOPMISR { bits }
            }
            #[doc = "Bit 3 - Receive DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmarxmis(&self) -> DMARXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXMISR { bits }
            }
            #[doc = "Bit 4 - Transmit DMA Masked Interrupt Status"]
            #[inline]
            pub fn dmatxmis(&self) -> DMATXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXMISR { bits }
            }
            #[doc = "Bit 5 - Transmit FIFO Request Interrupt Mask"]
            #[inline]
            pub fn txmis(&self) -> TXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXMISR { bits }
            }
            #[doc = "Bit 6 - Receive FIFO Request Interrupt Mask"]
            #[inline]
            pub fn rxmis(&self) -> RXMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXMISR { bits }
            }
            #[doc = "Bit 7 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfemis(&self) -> TXFEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFEMISR { bits }
            }
            #[doc = "Bit 8 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffmis(&self) -> RXFFMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFMISR { bits }
            }
        }
    }
    #[doc = "I2C Slave Interrupt Clear"]
    pub struct SICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Interrupt Clear"]
    pub mod sicr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SICR {
            #[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 _DATAICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAICW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _STARTICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STARTICW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STOPICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STOPICW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXICW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXICW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXICW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXFEICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXFEICW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXFFICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXFFICW<'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 = 8;
                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 = "Bit 0 - Data Interrupt Clear"]
            #[inline]
            pub fn dataic(&mut self) -> _DATAICW {
                _DATAICW { w: self }
            }
            #[doc = "Bit 1 - Start Condition Interrupt Clear"]
            #[inline]
            pub fn startic(&mut self) -> _STARTICW {
                _STARTICW { w: self }
            }
            #[doc = "Bit 2 - Stop Condition Interrupt Clear"]
            #[inline]
            pub fn stopic(&mut self) -> _STOPICW {
                _STOPICW { w: self }
            }
            #[doc = "Bit 3 - Receive DMA Interrupt Clear"]
            #[inline]
            pub fn dmarxic(&mut self) -> _DMARXICW {
                _DMARXICW { w: self }
            }
            #[doc = "Bit 4 - Transmit DMA Interrupt Clear"]
            #[inline]
            pub fn dmatxic(&mut self) -> _DMATXICW {
                _DMATXICW { w: self }
            }
            #[doc = "Bit 5 - Transmit Request Interrupt Mask"]
            #[inline]
            pub fn txic(&mut self) -> _TXICW {
                _TXICW { w: self }
            }
            #[doc = "Bit 6 - Receive Request Interrupt Mask"]
            #[inline]
            pub fn rxic(&mut self) -> _RXICW {
                _RXICW { w: self }
            }
            #[doc = "Bit 7 - Transmit FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn txfeic(&mut self) -> _TXFEICW {
                _TXFEICW { w: self }
            }
            #[doc = "Bit 8 - Receive FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rxffic(&mut self) -> _RXFFICW {
                _RXFFICW { w: self }
            }
        }
    }
    #[doc = "I2C Slave Own Address 2"]
    pub struct SOAR2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave Own Address 2"]
    pub mod soar2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SOAR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct OAR2R {
            bits: u8,
        }
        impl OAR2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct OAR2ENR {
            bits: bool,
        }
        impl OAR2ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _OAR2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _OAR2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OAR2ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OAR2ENW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:6 - I2C Slave Own Address 2"]
            #[inline]
            pub fn oar2(&self) -> OAR2R {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                OAR2R { bits }
            }
            #[doc = "Bit 7 - I2C Slave Own Address 2 Enable"]
            #[inline]
            pub fn oar2en(&self) -> OAR2ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OAR2ENR { bits }
            }
        }
        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 0:6 - I2C Slave Own Address 2"]
            #[inline]
            pub fn oar2(&mut self) -> _OAR2W {
                _OAR2W { w: self }
            }
            #[doc = "Bit 7 - I2C Slave Own Address 2 Enable"]
            #[inline]
            pub fn oar2en(&mut self) -> _OAR2ENW {
                _OAR2ENW { w: self }
            }
        }
    }
    #[doc = "I2C Slave ACK Control"]
    pub struct SACKCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Slave ACK Control"]
    pub mod sackctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SACKCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACKOENR {
            bits: bool,
        }
        impl ACKOENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACKOVALR {
            bits: bool,
        }
        impl ACKOVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACKOENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACKOENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACKOVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACKOVALW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Slave ACK Override Enable"]
            #[inline]
            pub fn ackoen(&self) -> ACKOENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACKOENR { bits }
            }
            #[doc = "Bit 1 - I2C Slave ACK Override Value"]
            #[inline]
            pub fn ackoval(&self) -> ACKOVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACKOVALR { bits }
            }
        }
        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 = "Bit 0 - I2C Slave ACK Override Enable"]
            #[inline]
            pub fn ackoen(&mut self) -> _ACKOENW {
                _ACKOENW { w: self }
            }
            #[doc = "Bit 1 - I2C Slave ACK Override Value"]
            #[inline]
            pub fn ackoval(&mut self) -> _ACKOVALW {
                _ACKOVALW { w: self }
            }
        }
    }
    #[doc = "I2C FIFO Data"]
    pub struct FIFODATA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C FIFO Data"]
    pub mod fifodata {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFODATA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - I2C TX FIFO Write Data Byte"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
        }
        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 0:7 - I2C TX FIFO Write Data Byte"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "I2C FIFO Control"]
    pub struct FIFOCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C FIFO Control"]
    pub mod fifoctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFOCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXTRIGR {
            bits: u8,
        }
        impl TXTRIGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMATXENAR {
            bits: bool,
        }
        impl DMATXENAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFLUSHR {
            bits: bool,
        }
        impl TXFLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXASGNMTR {
            bits: bool,
        }
        impl TXASGNMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXTRIGR {
            bits: u8,
        }
        impl RXTRIGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARXENAR {
            bits: bool,
        }
        impl DMARXENAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFLUSHR {
            bits: bool,
        }
        impl RXFLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXASGNMTR {
            bits: bool,
        }
        impl RXASGNMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXTRIGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXTRIGW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMATXENAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMATXENAW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXFLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXFLUSHW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXASGNMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXASGNMTW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXTRIGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXTRIGW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARXENAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARXENAW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXFLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXFLUSHW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXASGNMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXASGNMTW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - TX FIFO Trigger"]
            #[inline]
            pub fn txtrig(&self) -> TXTRIGR {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TXTRIGR { bits }
            }
            #[doc = "Bit 13 - DMA TX Channel Enable"]
            #[inline]
            pub fn dmatxena(&self) -> DMATXENAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMATXENAR { bits }
            }
            #[doc = "Bit 14 - TX FIFO Flush"]
            #[inline]
            pub fn txflush(&self) -> TXFLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFLUSHR { bits }
            }
            #[doc = "Bit 15 - TX Control Assignment"]
            #[inline]
            pub fn txasgnmt(&self) -> TXASGNMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXASGNMTR { bits }
            }
            #[doc = "Bits 16:18 - RX FIFO Trigger"]
            #[inline]
            pub fn rxtrig(&self) -> RXTRIGR {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RXTRIGR { bits }
            }
            #[doc = "Bit 29 - DMA RX Channel Enable"]
            #[inline]
            pub fn dmarxena(&self) -> DMARXENAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARXENAR { bits }
            }
            #[doc = "Bit 30 - RX FIFO Flush"]
            #[inline]
            pub fn rxflush(&self) -> RXFLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFLUSHR { bits }
            }
            #[doc = "Bit 31 - RX Control Assignment"]
            #[inline]
            pub fn rxasgnmt(&self) -> RXASGNMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXASGNMTR { bits }
            }
        }
        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 0:2 - TX FIFO Trigger"]
            #[inline]
            pub fn txtrig(&mut self) -> _TXTRIGW {
                _TXTRIGW { w: self }
            }
            #[doc = "Bit 13 - DMA TX Channel Enable"]
            #[inline]
            pub fn dmatxena(&mut self) -> _DMATXENAW {
                _DMATXENAW { w: self }
            }
            #[doc = "Bit 14 - TX FIFO Flush"]
            #[inline]
            pub fn txflush(&mut self) -> _TXFLUSHW {
                _TXFLUSHW { w: self }
            }
            #[doc = "Bit 15 - TX Control Assignment"]
            #[inline]
            pub fn txasgnmt(&mut self) -> _TXASGNMTW {
                _TXASGNMTW { w: self }
            }
            #[doc = "Bits 16:18 - RX FIFO Trigger"]
            #[inline]
            pub fn rxtrig(&mut self) -> _RXTRIGW {
                _RXTRIGW { w: self }
            }
            #[doc = "Bit 29 - DMA RX Channel Enable"]
            #[inline]
            pub fn dmarxena(&mut self) -> _DMARXENAW {
                _DMARXENAW { w: self }
            }
            #[doc = "Bit 30 - RX FIFO Flush"]
            #[inline]
            pub fn rxflush(&mut self) -> _RXFLUSHW {
                _RXFLUSHW { w: self }
            }
            #[doc = "Bit 31 - RX Control Assignment"]
            #[inline]
            pub fn rxasgnmt(&mut self) -> _RXASGNMTW {
                _RXASGNMTW { w: self }
            }
        }
    }
    #[doc = "I2C FIFO Status"]
    pub struct FIFOSTATUS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C FIFO Status"]
    pub mod fifostatus {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::FIFOSTATUS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFER {
            bits: bool,
        }
        impl TXFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFFR {
            bits: bool,
        }
        impl TXFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXBLWTRIGR {
            bits: bool,
        }
        impl TXBLWTRIGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFER {
            bits: bool,
        }
        impl RXFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFFR {
            bits: bool,
        }
        impl RXFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXABVTRIGR {
            bits: bool,
        }
        impl RXABVTRIGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - TX FIFO Empty"]
            #[inline]
            pub fn txfe(&self) -> TXFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFER { bits }
            }
            #[doc = "Bit 1 - TX FIFO Full"]
            #[inline]
            pub fn txff(&self) -> TXFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFFR { bits }
            }
            #[doc = "Bit 2 - TX FIFO Below Trigger Level"]
            #[inline]
            pub fn txblwtrig(&self) -> TXBLWTRIGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXBLWTRIGR { bits }
            }
            #[doc = "Bit 16 - RX FIFO Empty"]
            #[inline]
            pub fn rxfe(&self) -> RXFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFER { bits }
            }
            #[doc = "Bit 17 - RX FIFO Full"]
            #[inline]
            pub fn rxff(&self) -> RXFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXFFR { bits }
            }
            #[doc = "Bit 18 - RX FIFO Above Trigger Level"]
            #[inline]
            pub fn rxabvtrig(&self) -> RXABVTRIGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXABVTRIGR { bits }
            }
        }
    }
    #[doc = "I2C Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSR {
            bits: bool,
        }
        impl HSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - High-Speed Capable"]
            #[inline]
            pub fn hs(&self) -> HSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSR { bits }
            }
        }
    }
    #[doc = "I2C Peripheral Configuration"]
    pub struct PC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "I2C Peripheral Configuration"]
    pub mod pc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSR {
            bits: bool,
        }
        impl HSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - High-Speed Capable"]
            #[inline]
            pub fn hs(&self) -> HSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSR { bits }
            }
        }
    }
}
#[doc = "I2C1"]
pub struct I2C1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C1 {}
impl I2C1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x4002_1000 as *const _
    }
}
impl Deref for I2C1 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C1::ptr() }
    }
}
#[doc = "I2C2"]
pub struct I2C2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C2 {}
impl I2C2 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x4002_2000 as *const _
    }
}
impl Deref for I2C2 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C2::ptr() }
    }
}
#[doc = "I2C3"]
pub struct I2C3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C3 {}
impl I2C3 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x4002_3000 as *const _
    }
}
impl Deref for I2C3 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C3::ptr() }
    }
}
#[doc = "PWM register offsets"]
pub struct PWM0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for PWM0 {}
impl PWM0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const pwm0::RegisterBlock {
        0x4002_8000 as *const _
    }
}
impl Deref for PWM0 {
    type Target = pwm0::RegisterBlock;
    fn deref(&self) -> &pwm0::RegisterBlock {
        unsafe { &*PWM0::ptr() }
    }
}
#[doc = "PWM register offsets"]
pub mod pwm0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - PWM Master Control"]
        pub ctl: CTL,
        #[doc = "0x04 - PWM Time Base Sync"]
        pub sync: SYNC,
        #[doc = "0x08 - PWM Output Enable"]
        pub enable: ENABLE,
        #[doc = "0x0c - PWM Output Inversion"]
        pub invert: INVERT,
        #[doc = "0x10 - PWM Output Fault"]
        pub fault: FAULT,
        #[doc = "0x14 - PWM Interrupt Enable"]
        pub inten: INTEN,
        #[doc = "0x18 - PWM Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x1c - PWM Interrupt Status and Clear"]
        pub isc: ISC,
        #[doc = "0x20 - PWM Status"]
        pub status: STATUS,
        #[doc = "0x24 - PWM Fault Condition Value"]
        pub faultval: FAULTVAL,
        #[doc = "0x28 - PWM Enable Update"]
        pub enupd: ENUPD,
        _reserved0: [u8; 20usize],
        #[doc = "0x40 - PWM0 Control"]
        pub _0_ctl: _0_CTL,
        #[doc = "0x44 - PWM0 Interrupt and Trigger Enable"]
        pub _0_inten: _0_INTEN,
        #[doc = "0x48 - PWM0 Raw Interrupt Status"]
        pub _0_ris: _0_RIS,
        #[doc = "0x4c - PWM0 Interrupt Status and Clear"]
        pub _0_isc: _0_ISC,
        #[doc = "0x50 - PWM0 Load"]
        pub _0_load: _0_LOAD,
        #[doc = "0x54 - PWM0 Counter"]
        pub _0_count: _0_COUNT,
        #[doc = "0x58 - PWM0 Compare A"]
        pub _0_cmpa: _0_CMPA,
        #[doc = "0x5c - PWM0 Compare B"]
        pub _0_cmpb: _0_CMPB,
        #[doc = "0x60 - PWM0 Generator A Control"]
        pub _0_gena: _0_GENA,
        #[doc = "0x64 - PWM0 Generator B Control"]
        pub _0_genb: _0_GENB,
        #[doc = "0x68 - PWM0 Dead-Band Control"]
        pub _0_dbctl: _0_DBCTL,
        #[doc = "0x6c - PWM0 Dead-Band Rising-Edge Delay"]
        pub _0_dbrise: _0_DBRISE,
        #[doc = "0x70 - PWM0 Dead-Band Falling-Edge-Delay"]
        pub _0_dbfall: _0_DBFALL,
        #[doc = "0x74 - PWM0 Fault Source 0"]
        pub _0_fltsrc0: _0_FLTSRC0,
        #[doc = "0x78 - PWM0 Fault Source 1"]
        pub _0_fltsrc1: _0_FLTSRC1,
        #[doc = "0x7c - PWM0 Minimum Fault Period"]
        pub _0_minfltper: _0_MINFLTPER,
        #[doc = "0x80 - PWM1 Control"]
        pub _1_ctl: _1_CTL,
        #[doc = "0x84 - PWM1 Interrupt and Trigger Enable"]
        pub _1_inten: _1_INTEN,
        #[doc = "0x88 - PWM1 Raw Interrupt Status"]
        pub _1_ris: _1_RIS,
        #[doc = "0x8c - PWM1 Interrupt Status and Clear"]
        pub _1_isc: _1_ISC,
        #[doc = "0x90 - PWM1 Load"]
        pub _1_load: _1_LOAD,
        #[doc = "0x94 - PWM1 Counter"]
        pub _1_count: _1_COUNT,
        #[doc = "0x98 - PWM1 Compare A"]
        pub _1_cmpa: _1_CMPA,
        #[doc = "0x9c - PWM1 Compare B"]
        pub _1_cmpb: _1_CMPB,
        #[doc = "0xa0 - PWM1 Generator A Control"]
        pub _1_gena: _1_GENA,
        #[doc = "0xa4 - PWM1 Generator B Control"]
        pub _1_genb: _1_GENB,
        #[doc = "0xa8 - PWM1 Dead-Band Control"]
        pub _1_dbctl: _1_DBCTL,
        #[doc = "0xac - PWM1 Dead-Band Rising-Edge Delay"]
        pub _1_dbrise: _1_DBRISE,
        #[doc = "0xb0 - PWM1 Dead-Band Falling-Edge-Delay"]
        pub _1_dbfall: _1_DBFALL,
        #[doc = "0xb4 - PWM1 Fault Source 0"]
        pub _1_fltsrc0: _1_FLTSRC0,
        #[doc = "0xb8 - PWM1 Fault Source 1"]
        pub _1_fltsrc1: _1_FLTSRC1,
        #[doc = "0xbc - PWM1 Minimum Fault Period"]
        pub _1_minfltper: _1_MINFLTPER,
        #[doc = "0xc0 - PWM2 Control"]
        pub _2_ctl: _2_CTL,
        #[doc = "0xc4 - PWM2 Interrupt and Trigger Enable"]
        pub _2_inten: _2_INTEN,
        #[doc = "0xc8 - PWM2 Raw Interrupt Status"]
        pub _2_ris: _2_RIS,
        #[doc = "0xcc - PWM2 Interrupt Status and Clear"]
        pub _2_isc: _2_ISC,
        #[doc = "0xd0 - PWM2 Load"]
        pub _2_load: _2_LOAD,
        #[doc = "0xd4 - PWM2 Counter"]
        pub _2_count: _2_COUNT,
        #[doc = "0xd8 - PWM2 Compare A"]
        pub _2_cmpa: _2_CMPA,
        #[doc = "0xdc - PWM2 Compare B"]
        pub _2_cmpb: _2_CMPB,
        #[doc = "0xe0 - PWM2 Generator A Control"]
        pub _2_gena: _2_GENA,
        #[doc = "0xe4 - PWM2 Generator B Control"]
        pub _2_genb: _2_GENB,
        #[doc = "0xe8 - PWM2 Dead-Band Control"]
        pub _2_dbctl: _2_DBCTL,
        #[doc = "0xec - PWM2 Dead-Band Rising-Edge Delay"]
        pub _2_dbrise: _2_DBRISE,
        #[doc = "0xf0 - PWM2 Dead-Band Falling-Edge-Delay"]
        pub _2_dbfall: _2_DBFALL,
        #[doc = "0xf4 - PWM2 Fault Source 0"]
        pub _2_fltsrc0: _2_FLTSRC0,
        #[doc = "0xf8 - PWM2 Fault Source 1"]
        pub _2_fltsrc1: _2_FLTSRC1,
        #[doc = "0xfc - PWM2 Minimum Fault Period"]
        pub _2_minfltper: _2_MINFLTPER,
        #[doc = "0x100 - PWM3 Control"]
        pub _3_ctl: _3_CTL,
        #[doc = "0x104 - PWM3 Interrupt and Trigger Enable"]
        pub _3_inten: _3_INTEN,
        #[doc = "0x108 - PWM3 Raw Interrupt Status"]
        pub _3_ris: _3_RIS,
        #[doc = "0x10c - PWM3 Interrupt Status and Clear"]
        pub _3_isc: _3_ISC,
        #[doc = "0x110 - PWM3 Load"]
        pub _3_load: _3_LOAD,
        #[doc = "0x114 - PWM3 Counter"]
        pub _3_count: _3_COUNT,
        #[doc = "0x118 - PWM3 Compare A"]
        pub _3_cmpa: _3_CMPA,
        #[doc = "0x11c - PWM3 Compare B"]
        pub _3_cmpb: _3_CMPB,
        #[doc = "0x120 - PWM3 Generator A Control"]
        pub _3_gena: _3_GENA,
        #[doc = "0x124 - PWM3 Generator B Control"]
        pub _3_genb: _3_GENB,
        #[doc = "0x128 - PWM3 Dead-Band Control"]
        pub _3_dbctl: _3_DBCTL,
        #[doc = "0x12c - PWM3 Dead-Band Rising-Edge Delay"]
        pub _3_dbrise: _3_DBRISE,
        #[doc = "0x130 - PWM3 Dead-Band Falling-Edge-Delay"]
        pub _3_dbfall: _3_DBFALL,
        #[doc = "0x134 - PWM3 Fault Source 0"]
        pub _3_fltsrc0: _3_FLTSRC0,
        #[doc = "0x138 - PWM3 Fault Source 1"]
        pub _3_fltsrc1: _3_FLTSRC1,
        #[doc = "0x13c - PWM3 Minimum Fault Period"]
        pub _3_minfltper: _3_MINFLTPER,
        _reserved1: [u8; 1728usize],
        #[doc = "0x800 - PWM0 Fault Pin Logic Sense"]
        pub _0_fltsen: _0_FLTSEN,
        #[doc = "0x804 - PWM0 Fault Status 0"]
        pub _0_fltstat0: _0_FLTSTAT0,
        #[doc = "0x808 - PWM0 Fault Status 1"]
        pub _0_fltstat1: _0_FLTSTAT1,
        _reserved2: [u8; 116usize],
        #[doc = "0x880 - PWM1 Fault Pin Logic Sense"]
        pub _1_fltsen: _1_FLTSEN,
        #[doc = "0x884 - PWM1 Fault Status 0"]
        pub _1_fltstat0: _1_FLTSTAT0,
        #[doc = "0x888 - PWM1 Fault Status 1"]
        pub _1_fltstat1: _1_FLTSTAT1,
        _reserved3: [u8; 116usize],
        #[doc = "0x900 - PWM2 Fault Pin Logic Sense"]
        pub _2_fltsen: _2_FLTSEN,
        #[doc = "0x904 - PWM2 Fault Status 0"]
        pub _2_fltstat0: _2_FLTSTAT0,
        #[doc = "0x908 - PWM2 Fault Status 1"]
        pub _2_fltstat1: _2_FLTSTAT1,
        _reserved4: [u8; 116usize],
        #[doc = "0x980 - PWM3 Fault Pin Logic Sense"]
        pub _3_fltsen: _3_FLTSEN,
        #[doc = "0x984 - PWM3 Fault Status 0"]
        pub _3_fltstat0: _3_FLTSTAT0,
        #[doc = "0x988 - PWM3 Fault Status 1"]
        pub _3_fltstat1: _3_FLTSTAT1,
        _reserved5: [u8; 1588usize],
        #[doc = "0xfc0 - PWM Peripheral Properties"]
        pub pp: PP,
        _reserved6: [u8; 4usize],
        #[doc = "0xfc8 - PWM Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "PWM Master Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Master Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct GLOBALSYNC0R {
            bits: bool,
        }
        impl GLOBALSYNC0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GLOBALSYNC1R {
            bits: bool,
        }
        impl GLOBALSYNC1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GLOBALSYNC2R {
            bits: bool,
        }
        impl GLOBALSYNC2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GLOBALSYNC3R {
            bits: bool,
        }
        impl GLOBALSYNC3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _GLOBALSYNC0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GLOBALSYNC0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _GLOBALSYNC1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GLOBALSYNC1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GLOBALSYNC2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GLOBALSYNC2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GLOBALSYNC3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GLOBALSYNC3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Update PWM Generator 0"]
            #[inline]
            pub fn globalsync0(&self) -> GLOBALSYNC0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GLOBALSYNC0R { bits }
            }
            #[doc = "Bit 1 - Update PWM Generator 1"]
            #[inline]
            pub fn globalsync1(&self) -> GLOBALSYNC1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GLOBALSYNC1R { bits }
            }
            #[doc = "Bit 2 - Update PWM Generator 2"]
            #[inline]
            pub fn globalsync2(&self) -> GLOBALSYNC2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GLOBALSYNC2R { bits }
            }
            #[doc = "Bit 3 - Update PWM Generator 3"]
            #[inline]
            pub fn globalsync3(&self) -> GLOBALSYNC3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GLOBALSYNC3R { bits }
            }
        }
        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 = "Bit 0 - Update PWM Generator 0"]
            #[inline]
            pub fn globalsync0(&mut self) -> _GLOBALSYNC0W {
                _GLOBALSYNC0W { w: self }
            }
            #[doc = "Bit 1 - Update PWM Generator 1"]
            #[inline]
            pub fn globalsync1(&mut self) -> _GLOBALSYNC1W {
                _GLOBALSYNC1W { w: self }
            }
            #[doc = "Bit 2 - Update PWM Generator 2"]
            #[inline]
            pub fn globalsync2(&mut self) -> _GLOBALSYNC2W {
                _GLOBALSYNC2W { w: self }
            }
            #[doc = "Bit 3 - Update PWM Generator 3"]
            #[inline]
            pub fn globalsync3(&mut self) -> _GLOBALSYNC3W {
                _GLOBALSYNC3W { w: self }
            }
        }
    }
    #[doc = "PWM Time Base Sync"]
    pub struct SYNC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Time Base Sync"]
    pub mod sync {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SYNC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNC0R {
            bits: bool,
        }
        impl SYNC0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNC1R {
            bits: bool,
        }
        impl SYNC1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNC2R {
            bits: bool,
        }
        impl SYNC2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNC3R {
            bits: bool,
        }
        impl SYNC3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNC0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNC0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNC1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNC1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNC2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNC2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNC3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNC3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Reset Generator 0 Counter"]
            #[inline]
            pub fn sync0(&self) -> SYNC0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNC0R { bits }
            }
            #[doc = "Bit 1 - Reset Generator 1 Counter"]
            #[inline]
            pub fn sync1(&self) -> SYNC1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNC1R { bits }
            }
            #[doc = "Bit 2 - Reset Generator 2 Counter"]
            #[inline]
            pub fn sync2(&self) -> SYNC2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNC2R { bits }
            }
            #[doc = "Bit 3 - Reset Generator 3 Counter"]
            #[inline]
            pub fn sync3(&self) -> SYNC3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNC3R { bits }
            }
        }
        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 = "Bit 0 - Reset Generator 0 Counter"]
            #[inline]
            pub fn sync0(&mut self) -> _SYNC0W {
                _SYNC0W { w: self }
            }
            #[doc = "Bit 1 - Reset Generator 1 Counter"]
            #[inline]
            pub fn sync1(&mut self) -> _SYNC1W {
                _SYNC1W { w: self }
            }
            #[doc = "Bit 2 - Reset Generator 2 Counter"]
            #[inline]
            pub fn sync2(&mut self) -> _SYNC2W {
                _SYNC2W { w: self }
            }
            #[doc = "Bit 3 - Reset Generator 3 Counter"]
            #[inline]
            pub fn sync3(&mut self) -> _SYNC3W {
                _SYNC3W { w: self }
            }
        }
    }
    #[doc = "PWM Output Enable"]
    pub struct ENABLE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Output Enable"]
    pub mod enable {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ENABLE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM0ENR {
            bits: bool,
        }
        impl PWM0ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM1ENR {
            bits: bool,
        }
        impl PWM1ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM2ENR {
            bits: bool,
        }
        impl PWM2ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM3ENR {
            bits: bool,
        }
        impl PWM3ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM4ENR {
            bits: bool,
        }
        impl PWM4ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM5ENR {
            bits: bool,
        }
        impl PWM5ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM6ENR {
            bits: bool,
        }
        impl PWM6ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM7ENR {
            bits: bool,
        }
        impl PWM7ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM0ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM0ENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM1ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM1ENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM2ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM2ENW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM3ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM3ENW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM4ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM4ENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM5ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM5ENW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM6ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM6ENW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM7ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM7ENW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MnPWM0 Output Enable"]
            #[inline]
            pub fn pwm0en(&self) -> PWM0ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM0ENR { bits }
            }
            #[doc = "Bit 1 - MnPWM1 Output Enable"]
            #[inline]
            pub fn pwm1en(&self) -> PWM1ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM1ENR { bits }
            }
            #[doc = "Bit 2 - MnPWM2 Output Enable"]
            #[inline]
            pub fn pwm2en(&self) -> PWM2ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM2ENR { bits }
            }
            #[doc = "Bit 3 - MnPWM3 Output Enable"]
            #[inline]
            pub fn pwm3en(&self) -> PWM3ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM3ENR { bits }
            }
            #[doc = "Bit 4 - MnPWM4 Output Enable"]
            #[inline]
            pub fn pwm4en(&self) -> PWM4ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM4ENR { bits }
            }
            #[doc = "Bit 5 - MnPWM5 Output Enable"]
            #[inline]
            pub fn pwm5en(&self) -> PWM5ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM5ENR { bits }
            }
            #[doc = "Bit 6 - MnPWM6 Output Enable"]
            #[inline]
            pub fn pwm6en(&self) -> PWM6ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM6ENR { bits }
            }
            #[doc = "Bit 7 - MnPWM7 Output Enable"]
            #[inline]
            pub fn pwm7en(&self) -> PWM7ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM7ENR { bits }
            }
        }
        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 = "Bit 0 - MnPWM0 Output Enable"]
            #[inline]
            pub fn pwm0en(&mut self) -> _PWM0ENW {
                _PWM0ENW { w: self }
            }
            #[doc = "Bit 1 - MnPWM1 Output Enable"]
            #[inline]
            pub fn pwm1en(&mut self) -> _PWM1ENW {
                _PWM1ENW { w: self }
            }
            #[doc = "Bit 2 - MnPWM2 Output Enable"]
            #[inline]
            pub fn pwm2en(&mut self) -> _PWM2ENW {
                _PWM2ENW { w: self }
            }
            #[doc = "Bit 3 - MnPWM3 Output Enable"]
            #[inline]
            pub fn pwm3en(&mut self) -> _PWM3ENW {
                _PWM3ENW { w: self }
            }
            #[doc = "Bit 4 - MnPWM4 Output Enable"]
            #[inline]
            pub fn pwm4en(&mut self) -> _PWM4ENW {
                _PWM4ENW { w: self }
            }
            #[doc = "Bit 5 - MnPWM5 Output Enable"]
            #[inline]
            pub fn pwm5en(&mut self) -> _PWM5ENW {
                _PWM5ENW { w: self }
            }
            #[doc = "Bit 6 - MnPWM6 Output Enable"]
            #[inline]
            pub fn pwm6en(&mut self) -> _PWM6ENW {
                _PWM6ENW { w: self }
            }
            #[doc = "Bit 7 - MnPWM7 Output Enable"]
            #[inline]
            pub fn pwm7en(&mut self) -> _PWM7ENW {
                _PWM7ENW { w: self }
            }
        }
    }
    #[doc = "PWM Output Inversion"]
    pub struct INVERT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Output Inversion"]
    pub mod invert {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::INVERT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM0INVR {
            bits: bool,
        }
        impl PWM0INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM1INVR {
            bits: bool,
        }
        impl PWM1INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM2INVR {
            bits: bool,
        }
        impl PWM2INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM3INVR {
            bits: bool,
        }
        impl PWM3INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM4INVR {
            bits: bool,
        }
        impl PWM4INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM5INVR {
            bits: bool,
        }
        impl PWM5INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM6INVR {
            bits: bool,
        }
        impl PWM6INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM7INVR {
            bits: bool,
        }
        impl PWM7INVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM0INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM0INVW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM1INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM1INVW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM2INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM2INVW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM3INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM3INVW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM4INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM4INVW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM5INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM5INVW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM6INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM6INVW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM7INVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM7INVW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Invert MnPWM0 Signal"]
            #[inline]
            pub fn pwm0inv(&self) -> PWM0INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM0INVR { bits }
            }
            #[doc = "Bit 1 - Invert MnPWM1 Signal"]
            #[inline]
            pub fn pwm1inv(&self) -> PWM1INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM1INVR { bits }
            }
            #[doc = "Bit 2 - Invert MnPWM2 Signal"]
            #[inline]
            pub fn pwm2inv(&self) -> PWM2INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM2INVR { bits }
            }
            #[doc = "Bit 3 - Invert MnPWM3 Signal"]
            #[inline]
            pub fn pwm3inv(&self) -> PWM3INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM3INVR { bits }
            }
            #[doc = "Bit 4 - Invert MnPWM4 Signal"]
            #[inline]
            pub fn pwm4inv(&self) -> PWM4INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM4INVR { bits }
            }
            #[doc = "Bit 5 - Invert MnPWM5 Signal"]
            #[inline]
            pub fn pwm5inv(&self) -> PWM5INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM5INVR { bits }
            }
            #[doc = "Bit 6 - Invert MnPWM6 Signal"]
            #[inline]
            pub fn pwm6inv(&self) -> PWM6INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM6INVR { bits }
            }
            #[doc = "Bit 7 - Invert MnPWM7 Signal"]
            #[inline]
            pub fn pwm7inv(&self) -> PWM7INVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM7INVR { bits }
            }
        }
        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 = "Bit 0 - Invert MnPWM0 Signal"]
            #[inline]
            pub fn pwm0inv(&mut self) -> _PWM0INVW {
                _PWM0INVW { w: self }
            }
            #[doc = "Bit 1 - Invert MnPWM1 Signal"]
            #[inline]
            pub fn pwm1inv(&mut self) -> _PWM1INVW {
                _PWM1INVW { w: self }
            }
            #[doc = "Bit 2 - Invert MnPWM2 Signal"]
            #[inline]
            pub fn pwm2inv(&mut self) -> _PWM2INVW {
                _PWM2INVW { w: self }
            }
            #[doc = "Bit 3 - Invert MnPWM3 Signal"]
            #[inline]
            pub fn pwm3inv(&mut self) -> _PWM3INVW {
                _PWM3INVW { w: self }
            }
            #[doc = "Bit 4 - Invert MnPWM4 Signal"]
            #[inline]
            pub fn pwm4inv(&mut self) -> _PWM4INVW {
                _PWM4INVW { w: self }
            }
            #[doc = "Bit 5 - Invert MnPWM5 Signal"]
            #[inline]
            pub fn pwm5inv(&mut self) -> _PWM5INVW {
                _PWM5INVW { w: self }
            }
            #[doc = "Bit 6 - Invert MnPWM6 Signal"]
            #[inline]
            pub fn pwm6inv(&mut self) -> _PWM6INVW {
                _PWM6INVW { w: self }
            }
            #[doc = "Bit 7 - Invert MnPWM7 Signal"]
            #[inline]
            pub fn pwm7inv(&mut self) -> _PWM7INVW {
                _PWM7INVW { w: self }
            }
        }
    }
    #[doc = "PWM Output Fault"]
    pub struct FAULT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Output Fault"]
    pub mod fault {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FAULT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT4R {
            bits: bool,
        }
        impl FAULT4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT5R {
            bits: bool,
        }
        impl FAULT5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT6R {
            bits: bool,
        }
        impl FAULT6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT7R {
            bits: bool,
        }
        impl FAULT7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MnPWM0 Fault"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - MnPWM1 Fault"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - MnPWM2 Fault"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - MnPWM3 Fault"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
            #[doc = "Bit 4 - MnPWM4 Fault"]
            #[inline]
            pub fn fault4(&self) -> FAULT4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT4R { bits }
            }
            #[doc = "Bit 5 - MnPWM5 Fault"]
            #[inline]
            pub fn fault5(&self) -> FAULT5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT5R { bits }
            }
            #[doc = "Bit 6 - MnPWM6 Fault"]
            #[inline]
            pub fn fault6(&self) -> FAULT6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT6R { bits }
            }
            #[doc = "Bit 7 - MnPWM7 Fault"]
            #[inline]
            pub fn fault7(&self) -> FAULT7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT7R { bits }
            }
        }
        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 = "Bit 0 - MnPWM0 Fault"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - MnPWM1 Fault"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - MnPWM2 Fault"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - MnPWM3 Fault"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
            #[doc = "Bit 4 - MnPWM4 Fault"]
            #[inline]
            pub fn fault4(&mut self) -> _FAULT4W {
                _FAULT4W { w: self }
            }
            #[doc = "Bit 5 - MnPWM5 Fault"]
            #[inline]
            pub fn fault5(&mut self) -> _FAULT5W {
                _FAULT5W { w: self }
            }
            #[doc = "Bit 6 - MnPWM6 Fault"]
            #[inline]
            pub fn fault6(&mut self) -> _FAULT6W {
                _FAULT6W { w: self }
            }
            #[doc = "Bit 7 - MnPWM7 Fault"]
            #[inline]
            pub fn fault7(&mut self) -> _FAULT7W {
                _FAULT7W { w: self }
            }
        }
    }
    #[doc = "PWM Interrupt Enable"]
    pub struct INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Interrupt Enable"]
    pub mod inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM0R {
            bits: bool,
        }
        impl INTPWM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM1R {
            bits: bool,
        }
        impl INTPWM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM2R {
            bits: bool,
        }
        impl INTPWM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM3R {
            bits: bool,
        }
        impl INTPWM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT0R {
            bits: bool,
        }
        impl INTFAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT1R {
            bits: bool,
        }
        impl INTFAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT2R {
            bits: bool,
        }
        impl INTFAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT3R {
            bits: bool,
        }
        impl INTFAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT0W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT1W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT3W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM0 Interrupt Enable"]
            #[inline]
            pub fn intpwm0(&self) -> INTPWM0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM0R { bits }
            }
            #[doc = "Bit 1 - PWM1 Interrupt Enable"]
            #[inline]
            pub fn intpwm1(&self) -> INTPWM1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM1R { bits }
            }
            #[doc = "Bit 2 - PWM2 Interrupt Enable"]
            #[inline]
            pub fn intpwm2(&self) -> INTPWM2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM2R { bits }
            }
            #[doc = "Bit 3 - PWM3 Interrupt Enable"]
            #[inline]
            pub fn intpwm3(&self) -> INTPWM3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM3R { bits }
            }
            #[doc = "Bit 16 - Interrupt Fault 0"]
            #[inline]
            pub fn intfault0(&self) -> INTFAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT0R { bits }
            }
            #[doc = "Bit 17 - Interrupt Fault 1"]
            #[inline]
            pub fn intfault1(&self) -> INTFAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT1R { bits }
            }
            #[doc = "Bit 18 - Interrupt Fault 2"]
            #[inline]
            pub fn intfault2(&self) -> INTFAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT2R { bits }
            }
            #[doc = "Bit 19 - Interrupt Fault 3"]
            #[inline]
            pub fn intfault3(&self) -> INTFAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT3R { bits }
            }
        }
        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 = "Bit 0 - PWM0 Interrupt Enable"]
            #[inline]
            pub fn intpwm0(&mut self) -> _INTPWM0W {
                _INTPWM0W { w: self }
            }
            #[doc = "Bit 1 - PWM1 Interrupt Enable"]
            #[inline]
            pub fn intpwm1(&mut self) -> _INTPWM1W {
                _INTPWM1W { w: self }
            }
            #[doc = "Bit 2 - PWM2 Interrupt Enable"]
            #[inline]
            pub fn intpwm2(&mut self) -> _INTPWM2W {
                _INTPWM2W { w: self }
            }
            #[doc = "Bit 3 - PWM3 Interrupt Enable"]
            #[inline]
            pub fn intpwm3(&mut self) -> _INTPWM3W {
                _INTPWM3W { w: self }
            }
            #[doc = "Bit 16 - Interrupt Fault 0"]
            #[inline]
            pub fn intfault0(&mut self) -> _INTFAULT0W {
                _INTFAULT0W { w: self }
            }
            #[doc = "Bit 17 - Interrupt Fault 1"]
            #[inline]
            pub fn intfault1(&mut self) -> _INTFAULT1W {
                _INTFAULT1W { w: self }
            }
            #[doc = "Bit 18 - Interrupt Fault 2"]
            #[inline]
            pub fn intfault2(&mut self) -> _INTFAULT2W {
                _INTFAULT2W { w: self }
            }
            #[doc = "Bit 19 - Interrupt Fault 3"]
            #[inline]
            pub fn intfault3(&mut self) -> _INTFAULT3W {
                _INTFAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM0R {
            bits: bool,
        }
        impl INTPWM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM1R {
            bits: bool,
        }
        impl INTPWM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM2R {
            bits: bool,
        }
        impl INTPWM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM3R {
            bits: bool,
        }
        impl INTPWM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT0R {
            bits: bool,
        }
        impl INTFAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT1R {
            bits: bool,
        }
        impl INTFAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT2R {
            bits: bool,
        }
        impl INTFAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT3R {
            bits: bool,
        }
        impl INTFAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM0 Interrupt Asserted"]
            #[inline]
            pub fn intpwm0(&self) -> INTPWM0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM0R { bits }
            }
            #[doc = "Bit 1 - PWM1 Interrupt Asserted"]
            #[inline]
            pub fn intpwm1(&self) -> INTPWM1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM1R { bits }
            }
            #[doc = "Bit 2 - PWM2 Interrupt Asserted"]
            #[inline]
            pub fn intpwm2(&self) -> INTPWM2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM2R { bits }
            }
            #[doc = "Bit 3 - PWM3 Interrupt Asserted"]
            #[inline]
            pub fn intpwm3(&self) -> INTPWM3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM3R { bits }
            }
            #[doc = "Bit 16 - Interrupt Fault PWM 0"]
            #[inline]
            pub fn intfault0(&self) -> INTFAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT0R { bits }
            }
            #[doc = "Bit 17 - Interrupt Fault PWM 1"]
            #[inline]
            pub fn intfault1(&self) -> INTFAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT1R { bits }
            }
            #[doc = "Bit 18 - Interrupt Fault PWM 2"]
            #[inline]
            pub fn intfault2(&self) -> INTFAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT2R { bits }
            }
            #[doc = "Bit 19 - Interrupt Fault PWM 3"]
            #[inline]
            pub fn intfault3(&self) -> INTFAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT3R { bits }
            }
        }
    }
    #[doc = "PWM Interrupt Status and Clear"]
    pub struct ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Interrupt Status and Clear"]
    pub mod isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM0R {
            bits: bool,
        }
        impl INTPWM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM1R {
            bits: bool,
        }
        impl INTPWM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM2R {
            bits: bool,
        }
        impl INTPWM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPWM3R {
            bits: bool,
        }
        impl INTPWM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT0R {
            bits: bool,
        }
        impl INTFAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT1R {
            bits: bool,
        }
        impl INTFAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT2R {
            bits: bool,
        }
        impl INTFAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTFAULT3R {
            bits: bool,
        }
        impl INTFAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPWM3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPWM3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT0W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT1W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTFAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTFAULT3W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM0 Interrupt Status"]
            #[inline]
            pub fn intpwm0(&self) -> INTPWM0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM0R { bits }
            }
            #[doc = "Bit 1 - PWM1 Interrupt Status"]
            #[inline]
            pub fn intpwm1(&self) -> INTPWM1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM1R { bits }
            }
            #[doc = "Bit 2 - PWM2 Interrupt Status"]
            #[inline]
            pub fn intpwm2(&self) -> INTPWM2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM2R { bits }
            }
            #[doc = "Bit 3 - PWM3 Interrupt Status"]
            #[inline]
            pub fn intpwm3(&self) -> INTPWM3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPWM3R { bits }
            }
            #[doc = "Bit 16 - FAULT0 Interrupt Asserted"]
            #[inline]
            pub fn intfault0(&self) -> INTFAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT0R { bits }
            }
            #[doc = "Bit 17 - FAULT1 Interrupt Asserted"]
            #[inline]
            pub fn intfault1(&self) -> INTFAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT1R { bits }
            }
            #[doc = "Bit 18 - FAULT2 Interrupt Asserted"]
            #[inline]
            pub fn intfault2(&self) -> INTFAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT2R { bits }
            }
            #[doc = "Bit 19 - FAULT3 Interrupt Asserted"]
            #[inline]
            pub fn intfault3(&self) -> INTFAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTFAULT3R { bits }
            }
        }
        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 = "Bit 0 - PWM0 Interrupt Status"]
            #[inline]
            pub fn intpwm0(&mut self) -> _INTPWM0W {
                _INTPWM0W { w: self }
            }
            #[doc = "Bit 1 - PWM1 Interrupt Status"]
            #[inline]
            pub fn intpwm1(&mut self) -> _INTPWM1W {
                _INTPWM1W { w: self }
            }
            #[doc = "Bit 2 - PWM2 Interrupt Status"]
            #[inline]
            pub fn intpwm2(&mut self) -> _INTPWM2W {
                _INTPWM2W { w: self }
            }
            #[doc = "Bit 3 - PWM3 Interrupt Status"]
            #[inline]
            pub fn intpwm3(&mut self) -> _INTPWM3W {
                _INTPWM3W { w: self }
            }
            #[doc = "Bit 16 - FAULT0 Interrupt Asserted"]
            #[inline]
            pub fn intfault0(&mut self) -> _INTFAULT0W {
                _INTFAULT0W { w: self }
            }
            #[doc = "Bit 17 - FAULT1 Interrupt Asserted"]
            #[inline]
            pub fn intfault1(&mut self) -> _INTFAULT1W {
                _INTFAULT1W { w: self }
            }
            #[doc = "Bit 18 - FAULT2 Interrupt Asserted"]
            #[inline]
            pub fn intfault2(&mut self) -> _INTFAULT2W {
                _INTFAULT2W { w: self }
            }
            #[doc = "Bit 19 - FAULT3 Interrupt Asserted"]
            #[inline]
            pub fn intfault3(&mut self) -> _INTFAULT3W {
                _INTFAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM Status"]
    pub struct STATUS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Status"]
    pub mod status {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::STATUS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Generator 0 Fault Status"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Generator 1 Fault Status"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Generator 2 Fault Status"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Generator 3 Fault Status"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
    }
    #[doc = "PWM Fault Condition Value"]
    pub struct FAULTVAL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Fault Condition Value"]
    pub mod faultval {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FAULTVAL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM0R {
            bits: bool,
        }
        impl PWM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM1R {
            bits: bool,
        }
        impl PWM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM2R {
            bits: bool,
        }
        impl PWM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM3R {
            bits: bool,
        }
        impl PWM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM4R {
            bits: bool,
        }
        impl PWM4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM5R {
            bits: bool,
        }
        impl PWM5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM6R {
            bits: bool,
        }
        impl PWM6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWM7R {
            bits: bool,
        }
        impl PWM7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWM7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWM7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MnPWM0 Fault Value"]
            #[inline]
            pub fn pwm0(&self) -> PWM0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM0R { bits }
            }
            #[doc = "Bit 1 - MnPWM1 Fault Value"]
            #[inline]
            pub fn pwm1(&self) -> PWM1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM1R { bits }
            }
            #[doc = "Bit 2 - MnPWM2 Fault Value"]
            #[inline]
            pub fn pwm2(&self) -> PWM2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM2R { bits }
            }
            #[doc = "Bit 3 - MnPWM3 Fault Value"]
            #[inline]
            pub fn pwm3(&self) -> PWM3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM3R { bits }
            }
            #[doc = "Bit 4 - MnPWM4 Fault Value"]
            #[inline]
            pub fn pwm4(&self) -> PWM4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM4R { bits }
            }
            #[doc = "Bit 5 - MnPWM5 Fault Value"]
            #[inline]
            pub fn pwm5(&self) -> PWM5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM5R { bits }
            }
            #[doc = "Bit 6 - MnPWM6 Fault Value"]
            #[inline]
            pub fn pwm6(&self) -> PWM6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM6R { bits }
            }
            #[doc = "Bit 7 - MnPWM7 Fault Value"]
            #[inline]
            pub fn pwm7(&self) -> PWM7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWM7R { bits }
            }
        }
        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 = "Bit 0 - MnPWM0 Fault Value"]
            #[inline]
            pub fn pwm0(&mut self) -> _PWM0W {
                _PWM0W { w: self }
            }
            #[doc = "Bit 1 - MnPWM1 Fault Value"]
            #[inline]
            pub fn pwm1(&mut self) -> _PWM1W {
                _PWM1W { w: self }
            }
            #[doc = "Bit 2 - MnPWM2 Fault Value"]
            #[inline]
            pub fn pwm2(&mut self) -> _PWM2W {
                _PWM2W { w: self }
            }
            #[doc = "Bit 3 - MnPWM3 Fault Value"]
            #[inline]
            pub fn pwm3(&mut self) -> _PWM3W {
                _PWM3W { w: self }
            }
            #[doc = "Bit 4 - MnPWM4 Fault Value"]
            #[inline]
            pub fn pwm4(&mut self) -> _PWM4W {
                _PWM4W { w: self }
            }
            #[doc = "Bit 5 - MnPWM5 Fault Value"]
            #[inline]
            pub fn pwm5(&mut self) -> _PWM5W {
                _PWM5W { w: self }
            }
            #[doc = "Bit 6 - MnPWM6 Fault Value"]
            #[inline]
            pub fn pwm6(&mut self) -> _PWM6W {
                _PWM6W { w: self }
            }
            #[doc = "Bit 7 - MnPWM7 Fault Value"]
            #[inline]
            pub fn pwm7(&mut self) -> _PWM7W {
                _PWM7W { w: self }
            }
        }
    }
    #[doc = "PWM Enable Update"]
    pub struct ENUPD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Enable Update"]
    pub mod enupd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ENUPD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ENUPD0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD0R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD0R::IMM => 0,
                    ENUPD0R::LSYNC => 0x02,
                    ENUPD0R::GSYNC => 0x03,
                    ENUPD0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD0R {
                match value {
                    0 => ENUPD0R::IMM,
                    2 => ENUPD0R::LSYNC,
                    3 => ENUPD0R::GSYNC,
                    i => ENUPD0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD0R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD0R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD0R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD1R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD1R::IMM => 0,
                    ENUPD1R::LSYNC => 0x02,
                    ENUPD1R::GSYNC => 0x03,
                    ENUPD1R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD1R {
                match value {
                    0 => ENUPD1R::IMM,
                    2 => ENUPD1R::LSYNC,
                    3 => ENUPD1R::GSYNC,
                    i => ENUPD1R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD1R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD1R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD1R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD2`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD2R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD2R::IMM => 0,
                    ENUPD2R::LSYNC => 0x02,
                    ENUPD2R::GSYNC => 0x03,
                    ENUPD2R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD2R {
                match value {
                    0 => ENUPD2R::IMM,
                    2 => ENUPD2R::LSYNC,
                    3 => ENUPD2R::GSYNC,
                    i => ENUPD2R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD2R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD2R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD2R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD3`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD3R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD3R::IMM => 0,
                    ENUPD3R::LSYNC => 0x02,
                    ENUPD3R::GSYNC => 0x03,
                    ENUPD3R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD3R {
                match value {
                    0 => ENUPD3R::IMM,
                    2 => ENUPD3R::LSYNC,
                    3 => ENUPD3R::GSYNC,
                    i => ENUPD3R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD3R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD3R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD3R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD4`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD4R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD4R::IMM => 0,
                    ENUPD4R::LSYNC => 0x02,
                    ENUPD4R::GSYNC => 0x03,
                    ENUPD4R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD4R {
                match value {
                    0 => ENUPD4R::IMM,
                    2 => ENUPD4R::LSYNC,
                    3 => ENUPD4R::GSYNC,
                    i => ENUPD4R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD4R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD4R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD4R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD5`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD5R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD5R::IMM => 0,
                    ENUPD5R::LSYNC => 0x02,
                    ENUPD5R::GSYNC => 0x03,
                    ENUPD5R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD5R {
                match value {
                    0 => ENUPD5R::IMM,
                    2 => ENUPD5R::LSYNC,
                    3 => ENUPD5R::GSYNC,
                    i => ENUPD5R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD5R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD5R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD5R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD6`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD6R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD6R::IMM => 0,
                    ENUPD6R::LSYNC => 0x02,
                    ENUPD6R::GSYNC => 0x03,
                    ENUPD6R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD6R {
                match value {
                    0 => ENUPD6R::IMM,
                    2 => ENUPD6R::LSYNC,
                    3 => ENUPD6R::GSYNC,
                    i => ENUPD6R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD6R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD6R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD6R::GSYNC
            }
        }
        #[doc = "Possible values of the field `ENUPD7`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENUPD7R {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENUPD7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENUPD7R::IMM => 0,
                    ENUPD7R::LSYNC => 0x02,
                    ENUPD7R::GSYNC => 0x03,
                    ENUPD7R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENUPD7R {
                match value {
                    0 => ENUPD7R::IMM,
                    2 => ENUPD7R::LSYNC,
                    3 => ENUPD7R::GSYNC,
                    i => ENUPD7R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMM`"]
            #[inline]
            pub fn is_imm(&self) -> bool {
                *self == ENUPD7R::IMM
            }
            #[doc = "Checks if the value of the field is `LSYNC`"]
            #[inline]
            pub fn is_lsync(&self) -> bool {
                *self == ENUPD7R::LSYNC
            }
            #[doc = "Checks if the value of the field is `GSYNC`"]
            #[inline]
            pub fn is_gsync(&self) -> bool {
                *self == ENUPD7R::GSYNC
            }
        }
        #[doc = "Values that can be written to the field `ENUPD0`"]
        pub enum ENUPD0W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD0W::IMM => 0,
                    ENUPD0W::LSYNC => 2,
                    ENUPD0W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD0W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD0W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD0W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD1`"]
        pub enum ENUPD1W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD1W::IMM => 0,
                    ENUPD1W::LSYNC => 2,
                    ENUPD1W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD1W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD1W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD1W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD1W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD2`"]
        pub enum ENUPD2W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD2W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD2W::IMM => 0,
                    ENUPD2W::LSYNC => 2,
                    ENUPD2W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD2W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD2W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD2W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD2W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD2W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD3`"]
        pub enum ENUPD3W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD3W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD3W::IMM => 0,
                    ENUPD3W::LSYNC => 2,
                    ENUPD3W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD3W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD3W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD3W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD3W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD3W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD4`"]
        pub enum ENUPD4W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD4W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD4W::IMM => 0,
                    ENUPD4W::LSYNC => 2,
                    ENUPD4W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD4W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD4W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD4W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD4W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD4W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD5`"]
        pub enum ENUPD5W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD5W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD5W::IMM => 0,
                    ENUPD5W::LSYNC => 2,
                    ENUPD5W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD5W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD5W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD5W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD5W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD5W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD6`"]
        pub enum ENUPD6W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD6W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD6W::IMM => 0,
                    ENUPD6W::LSYNC => 2,
                    ENUPD6W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD6W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD6W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD6W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD6W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD6W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENUPD7`"]
        pub enum ENUPD7W {
            #[doc = "Immediate"]
            IMM,
            #[doc = "Locally Synchronized"]
            LSYNC,
            #[doc = "Globally Synchronized"]
            GSYNC,
        }
        impl ENUPD7W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENUPD7W::IMM => 0,
                    ENUPD7W::LSYNC => 2,
                    ENUPD7W::GSYNC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENUPD7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENUPD7W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENUPD7W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn imm(self) -> &'a mut W {
                self.variant(ENUPD7W::IMM)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn lsync(self) -> &'a mut W {
                self.variant(ENUPD7W::LSYNC)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gsync(self) -> &'a mut W {
                self.variant(ENUPD7W::GSYNC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - MnPWM0 Enable Update Mode"]
            #[inline]
            pub fn enupd0(&self) -> ENUPD0R {
                ENUPD0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - MnPWM1 Enable Update Mode"]
            #[inline]
            pub fn enupd1(&self) -> ENUPD1R {
                ENUPD1R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - MnPWM2 Enable Update Mode"]
            #[inline]
            pub fn enupd2(&self) -> ENUPD2R {
                ENUPD2R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - MnPWM3 Enable Update Mode"]
            #[inline]
            pub fn enupd3(&self) -> ENUPD3R {
                ENUPD3R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - MnPWM4 Enable Update Mode"]
            #[inline]
            pub fn enupd4(&self) -> ENUPD4R {
                ENUPD4R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - MnPWM5 Enable Update Mode"]
            #[inline]
            pub fn enupd5(&self) -> ENUPD5R {
                ENUPD5R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - MnPWM6 Enable Update Mode"]
            #[inline]
            pub fn enupd6(&self) -> ENUPD6R {
                ENUPD6R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - MnPWM7 Enable Update Mode"]
            #[inline]
            pub fn enupd7(&self) -> ENUPD7R {
                ENUPD7R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - MnPWM0 Enable Update Mode"]
            #[inline]
            pub fn enupd0(&mut self) -> _ENUPD0W {
                _ENUPD0W { w: self }
            }
            #[doc = "Bits 2:3 - MnPWM1 Enable Update Mode"]
            #[inline]
            pub fn enupd1(&mut self) -> _ENUPD1W {
                _ENUPD1W { w: self }
            }
            #[doc = "Bits 4:5 - MnPWM2 Enable Update Mode"]
            #[inline]
            pub fn enupd2(&mut self) -> _ENUPD2W {
                _ENUPD2W { w: self }
            }
            #[doc = "Bits 6:7 - MnPWM3 Enable Update Mode"]
            #[inline]
            pub fn enupd3(&mut self) -> _ENUPD3W {
                _ENUPD3W { w: self }
            }
            #[doc = "Bits 8:9 - MnPWM4 Enable Update Mode"]
            #[inline]
            pub fn enupd4(&mut self) -> _ENUPD4W {
                _ENUPD4W { w: self }
            }
            #[doc = "Bits 10:11 - MnPWM5 Enable Update Mode"]
            #[inline]
            pub fn enupd5(&mut self) -> _ENUPD5W {
                _ENUPD5W { w: self }
            }
            #[doc = "Bits 12:13 - MnPWM6 Enable Update Mode"]
            #[inline]
            pub fn enupd6(&mut self) -> _ENUPD6W {
                _ENUPD6W { w: self }
            }
            #[doc = "Bits 14:15 - MnPWM7 Enable Update Mode"]
            #[inline]
            pub fn enupd7(&mut self) -> _ENUPD7W {
                _ENUPD7W { w: self }
            }
        }
    }
    #[doc = "PWM0 Control"]
    pub struct _0_CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Control"]
    pub mod _0_ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DEBUGR {
            bits: bool,
        }
        impl DEBUGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADUPDR {
            bits: bool,
        }
        impl LOADUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPAUPDR {
            bits: bool,
        }
        impl CMPAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPBUPDR {
            bits: bool,
        }
        impl CMPBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `GENAUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENAUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENAUPDR::I => 0,
                    GENAUPDR::LS => 0x02,
                    GENAUPDR::GS => 0x03,
                    GENAUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENAUPDR {
                match value {
                    0 => GENAUPDR::I,
                    2 => GENAUPDR::LS,
                    3 => GENAUPDR::GS,
                    i => GENAUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENAUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENAUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENAUPDR::GS
            }
        }
        #[doc = "Possible values of the field `GENBUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENBUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENBUPDR::I => 0,
                    GENBUPDR::LS => 0x02,
                    GENBUPDR::GS => 0x03,
                    GENBUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENBUPDR {
                match value {
                    0 => GENBUPDR::I,
                    2 => GENBUPDR::LS,
                    3 => GENBUPDR::GS,
                    i => GENBUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENBUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENBUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENBUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBCTLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBCTLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBCTLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBCTLUPDR::I => 0,
                    DBCTLUPDR::LS => 0x02,
                    DBCTLUPDR::GS => 0x03,
                    DBCTLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBCTLUPDR {
                match value {
                    0 => DBCTLUPDR::I,
                    2 => DBCTLUPDR::LS,
                    3 => DBCTLUPDR::GS,
                    i => DBCTLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBCTLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBCTLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBCTLUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBRISEUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBRISEUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBRISEUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBRISEUPDR::I => 0,
                    DBRISEUPDR::LS => 0x02,
                    DBRISEUPDR::GS => 0x03,
                    DBRISEUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBRISEUPDR {
                match value {
                    0 => DBRISEUPDR::I,
                    2 => DBRISEUPDR::LS,
                    3 => DBRISEUPDR::GS,
                    i => DBRISEUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBRISEUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBRISEUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBRISEUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBFALLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBFALLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBFALLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBFALLUPDR::I => 0,
                    DBFALLUPDR::LS => 0x02,
                    DBFALLUPDR::GS => 0x03,
                    DBFALLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBFALLUPDR {
                match value {
                    0 => DBFALLUPDR::I,
                    2 => DBFALLUPDR::LS,
                    3 => DBFALLUPDR::GS,
                    i => DBFALLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBFALLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBFALLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBFALLUPDR::GS
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLTSRCR {
            bits: bool,
        }
        impl FLTSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINFLTPERR {
            bits: bool,
        }
        impl MINFLTPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LATCHR {
            bits: bool,
        }
        impl LATCHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEBUGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEBUGW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADUPDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPAUPDW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPBUPDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENAUPD`"]
        pub enum GENAUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENAUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENAUPDW::I => 0,
                    GENAUPDW::LS => 2,
                    GENAUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENAUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENAUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENAUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENAUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENAUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENBUPD`"]
        pub enum GENBUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENBUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENBUPDW::I => 0,
                    GENBUPDW::LS => 2,
                    GENBUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENBUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENBUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENBUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENBUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENBUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBCTLUPD`"]
        pub enum DBCTLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBCTLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBCTLUPDW::I => 0,
                    DBCTLUPDW::LS => 2,
                    DBCTLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBCTLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBCTLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBCTLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBCTLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBCTLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBCTLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBRISEUPD`"]
        pub enum DBRISEUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBRISEUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBRISEUPDW::I => 0,
                    DBRISEUPDW::LS => 2,
                    DBRISEUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBRISEUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBRISEUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBRISEUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBRISEUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBRISEUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBRISEUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBFALLUPD`"]
        pub enum DBFALLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBFALLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBFALLUPDW::I => 0,
                    DBFALLUPDW::LS => 2,
                    DBFALLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBFALLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBFALLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBFALLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBFALLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBFALLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBFALLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLTSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLTSRCW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINFLTPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINFLTPERW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LATCHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LATCHW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&self) -> DEBUGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DEBUGR { bits }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&self) -> LOADUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOADUPDR { bits }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&self) -> CMPAUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPAUPDR { bits }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&self) -> CMPBUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPBUPDR { bits }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&self) -> GENAUPDR {
                GENAUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&self) -> GENBUPDR {
                GENBUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&self) -> DBCTLUPDR {
                DBCTLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&self) -> DBRISEUPDR {
                DBRISEUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&self) -> DBFALLUPDR {
                DBFALLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&self) -> FLTSRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FLTSRCR { bits }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&self) -> MINFLTPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MINFLTPERR { bits }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&self) -> LATCHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LATCHR { bits }
            }
        }
        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 = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&mut self) -> _DEBUGW {
                _DEBUGW { w: self }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&mut self) -> _LOADUPDW {
                _LOADUPDW { w: self }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&mut self) -> _CMPAUPDW {
                _CMPAUPDW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&mut self) -> _CMPBUPDW {
                _CMPBUPDW { w: self }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&mut self) -> _GENAUPDW {
                _GENAUPDW { w: self }
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&mut self) -> _GENBUPDW {
                _GENBUPDW { w: self }
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&mut self) -> _DBCTLUPDW {
                _DBCTLUPDW { w: self }
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&mut self) -> _DBRISEUPDW {
                _DBRISEUPDW { w: self }
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&mut self) -> _DBFALLUPDW {
                _DBFALLUPDW { w: self }
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&mut self) -> _FLTSRCW {
                _FLTSRCW { w: self }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&mut self) -> _MINFLTPERW {
                _MINFLTPERW { w: self }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&mut self) -> _LATCHW {
                _LATCHW { w: self }
            }
        }
    }
    #[doc = "PWM0 Interrupt and Trigger Enable"]
    pub struct _0_INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Interrupt and Trigger Enable"]
    pub mod _0_inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTZEROR {
            bits: bool,
        }
        impl TRCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTLOADR {
            bits: bool,
        }
        impl TRCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPAUR {
            bits: bool,
        }
        impl TRCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPADR {
            bits: bool,
        }
        impl TRCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBUR {
            bits: bool,
        }
        impl TRCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBDR {
            bits: bool,
        }
        impl TRCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTZEROW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTLOADW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPAUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPADW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBUW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&self) -> TRCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTZEROR { bits }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&self) -> TRCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTLOADR { bits }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&self) -> TRCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPAUR { bits }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&self) -> TRCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPADR { bits }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&self) -> TRCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBUR { bits }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&self) -> TRCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&mut self) -> _TRCNTZEROW {
                _TRCNTZEROW { w: self }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&mut self) -> _TRCNTLOADW {
                _TRCNTLOADW { w: self }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&mut self) -> _TRCMPAUW {
                _TRCMPAUW { w: self }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&mut self) -> _TRCMPADW {
                _TRCMPADW { w: self }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&mut self) -> _TRCMPBUW {
                _TRCMPBUW { w: self }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&mut self) -> _TRCMPBDW {
                _TRCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM0 Raw Interrupt Status"]
    pub struct _0_RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Raw Interrupt Status"]
    pub mod _0_ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_0_RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt Status"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt Status"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt Status"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt Status"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt Status"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt Status"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
    }
    #[doc = "PWM0 Interrupt Status and Clear"]
    pub struct _0_ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Interrupt Status and Clear"]
    pub mod _0_isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM0 Load"]
    pub struct _0_LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Load"]
    pub mod _0_load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADR {
            bits: u16,
        }
        impl LOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&self) -> LOADR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                LOADR { bits }
            }
        }
        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 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&mut self) -> _LOADW {
                _LOADW { w: self }
            }
        }
    }
    #[doc = "PWM0 Counter"]
    pub struct _0_COUNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Counter"]
    pub mod _0_count {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_0_COUNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Value"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "PWM0 Compare A"]
    pub struct _0_CMPA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Compare A"]
    pub mod _0_cmpa {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_CMPA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPAR {
            bits: u16,
        }
        impl COMPAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&self) -> COMPAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPAR { bits }
            }
        }
        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 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&mut self) -> _COMPAW {
                _COMPAW { w: self }
            }
        }
    }
    #[doc = "PWM0 Compare B"]
    pub struct _0_CMPB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Compare B"]
    pub mod _0_cmpb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_CMPB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPBR {
            bits: u16,
        }
        impl COMPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPBW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&self) -> COMPBR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPBR { bits }
            }
        }
        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 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&mut self) -> _COMPBW {
                _COMPBW { w: self }
            }
        }
    }
    #[doc = "PWM0 Generator A Control"]
    pub struct _0_GENA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Generator A Control"]
    pub mod _0_gena {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_GENA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM0 Generator B Control"]
    pub struct _0_GENB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Generator B Control"]
    pub mod _0_genb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_GENB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM0 Dead-Band Control"]
    pub struct _0_DBCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Dead-Band Control"]
    pub mod _0_dbctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_DBCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
        }
        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 = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
        }
    }
    #[doc = "PWM0 Dead-Band Rising-Edge Delay"]
    pub struct _0_DBRISE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Dead-Band Rising-Edge Delay"]
    pub mod _0_dbrise {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_DBRISE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DELAYR {
            bits: u16,
        }
        impl DELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn delay(&self) -> DELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn delay(&mut self) -> _DELAYW {
                _DELAYW { w: self }
            }
        }
    }
    #[doc = "PWM0 Dead-Band Falling-Edge-Delay"]
    pub struct _0_DBFALL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Dead-Band Falling-Edge-Delay"]
    pub mod _0_dbfall {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_DBFALL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DELAYR {
            bits: u16,
        }
        impl DELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn delay(&self) -> DELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn delay(&mut self) -> _DELAYW {
                _DELAYW { w: self }
            }
        }
    }
    #[doc = "PWM0 Fault Source 0"]
    pub struct _0_FLTSRC0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Fault Source 0"]
    pub mod _0_fltsrc0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_FLTSRC0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM0 Fault Source 1"]
    pub struct _0_FLTSRC1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Fault Source 1"]
    pub mod _0_fltsrc1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_FLTSRC1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM0 Minimum Fault Period"]
    pub struct _0_MINFLTPER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Minimum Fault Period"]
    pub mod _0_minfltper {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_MINFLTPER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINFLTPERR {
            bits: u16,
        }
        impl MINFLTPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINFLTPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINFLTPERW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&self) -> MINFLTPERR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MINFLTPERR { bits }
            }
        }
        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 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&mut self) -> _MINFLTPERW {
                _MINFLTPERW { w: self }
            }
        }
    }
    #[doc = "PWM1 Control"]
    pub struct _1_CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Control"]
    pub mod _1_ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DEBUGR {
            bits: bool,
        }
        impl DEBUGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADUPDR {
            bits: bool,
        }
        impl LOADUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPAUPDR {
            bits: bool,
        }
        impl CMPAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPBUPDR {
            bits: bool,
        }
        impl CMPBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `GENAUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENAUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENAUPDR::I => 0,
                    GENAUPDR::LS => 0x02,
                    GENAUPDR::GS => 0x03,
                    GENAUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENAUPDR {
                match value {
                    0 => GENAUPDR::I,
                    2 => GENAUPDR::LS,
                    3 => GENAUPDR::GS,
                    i => GENAUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENAUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENAUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENAUPDR::GS
            }
        }
        #[doc = "Possible values of the field `GENBUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENBUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENBUPDR::I => 0,
                    GENBUPDR::LS => 0x02,
                    GENBUPDR::GS => 0x03,
                    GENBUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENBUPDR {
                match value {
                    0 => GENBUPDR::I,
                    2 => GENBUPDR::LS,
                    3 => GENBUPDR::GS,
                    i => GENBUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENBUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENBUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENBUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBCTLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBCTLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBCTLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBCTLUPDR::I => 0,
                    DBCTLUPDR::LS => 0x02,
                    DBCTLUPDR::GS => 0x03,
                    DBCTLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBCTLUPDR {
                match value {
                    0 => DBCTLUPDR::I,
                    2 => DBCTLUPDR::LS,
                    3 => DBCTLUPDR::GS,
                    i => DBCTLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBCTLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBCTLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBCTLUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBRISEUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBRISEUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBRISEUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBRISEUPDR::I => 0,
                    DBRISEUPDR::LS => 0x02,
                    DBRISEUPDR::GS => 0x03,
                    DBRISEUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBRISEUPDR {
                match value {
                    0 => DBRISEUPDR::I,
                    2 => DBRISEUPDR::LS,
                    3 => DBRISEUPDR::GS,
                    i => DBRISEUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBRISEUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBRISEUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBRISEUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBFALLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBFALLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBFALLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBFALLUPDR::I => 0,
                    DBFALLUPDR::LS => 0x02,
                    DBFALLUPDR::GS => 0x03,
                    DBFALLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBFALLUPDR {
                match value {
                    0 => DBFALLUPDR::I,
                    2 => DBFALLUPDR::LS,
                    3 => DBFALLUPDR::GS,
                    i => DBFALLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBFALLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBFALLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBFALLUPDR::GS
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLTSRCR {
            bits: bool,
        }
        impl FLTSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINFLTPERR {
            bits: bool,
        }
        impl MINFLTPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LATCHR {
            bits: bool,
        }
        impl LATCHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEBUGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEBUGW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADUPDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPAUPDW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPBUPDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENAUPD`"]
        pub enum GENAUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENAUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENAUPDW::I => 0,
                    GENAUPDW::LS => 2,
                    GENAUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENAUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENAUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENAUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENAUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENAUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENBUPD`"]
        pub enum GENBUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENBUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENBUPDW::I => 0,
                    GENBUPDW::LS => 2,
                    GENBUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENBUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENBUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENBUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENBUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENBUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBCTLUPD`"]
        pub enum DBCTLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBCTLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBCTLUPDW::I => 0,
                    DBCTLUPDW::LS => 2,
                    DBCTLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBCTLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBCTLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBCTLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBCTLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBCTLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBCTLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBRISEUPD`"]
        pub enum DBRISEUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBRISEUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBRISEUPDW::I => 0,
                    DBRISEUPDW::LS => 2,
                    DBRISEUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBRISEUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBRISEUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBRISEUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBRISEUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBRISEUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBRISEUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBFALLUPD`"]
        pub enum DBFALLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBFALLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBFALLUPDW::I => 0,
                    DBFALLUPDW::LS => 2,
                    DBFALLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBFALLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBFALLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBFALLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBFALLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBFALLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBFALLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLTSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLTSRCW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINFLTPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINFLTPERW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LATCHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LATCHW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&self) -> DEBUGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DEBUGR { bits }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&self) -> LOADUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOADUPDR { bits }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&self) -> CMPAUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPAUPDR { bits }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&self) -> CMPBUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPBUPDR { bits }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&self) -> GENAUPDR {
                GENAUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&self) -> GENBUPDR {
                GENBUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&self) -> DBCTLUPDR {
                DBCTLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&self) -> DBRISEUPDR {
                DBRISEUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&self) -> DBFALLUPDR {
                DBFALLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&self) -> FLTSRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FLTSRCR { bits }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&self) -> MINFLTPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MINFLTPERR { bits }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&self) -> LATCHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LATCHR { bits }
            }
        }
        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 = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&mut self) -> _DEBUGW {
                _DEBUGW { w: self }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&mut self) -> _LOADUPDW {
                _LOADUPDW { w: self }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&mut self) -> _CMPAUPDW {
                _CMPAUPDW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&mut self) -> _CMPBUPDW {
                _CMPBUPDW { w: self }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&mut self) -> _GENAUPDW {
                _GENAUPDW { w: self }
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&mut self) -> _GENBUPDW {
                _GENBUPDW { w: self }
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&mut self) -> _DBCTLUPDW {
                _DBCTLUPDW { w: self }
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&mut self) -> _DBRISEUPDW {
                _DBRISEUPDW { w: self }
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&mut self) -> _DBFALLUPDW {
                _DBFALLUPDW { w: self }
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&mut self) -> _FLTSRCW {
                _FLTSRCW { w: self }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&mut self) -> _MINFLTPERW {
                _MINFLTPERW { w: self }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&mut self) -> _LATCHW {
                _LATCHW { w: self }
            }
        }
    }
    #[doc = "PWM1 Interrupt and Trigger Enable"]
    pub struct _1_INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Interrupt and Trigger Enable"]
    pub mod _1_inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTZEROR {
            bits: bool,
        }
        impl TRCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTLOADR {
            bits: bool,
        }
        impl TRCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPAUR {
            bits: bool,
        }
        impl TRCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPADR {
            bits: bool,
        }
        impl TRCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBUR {
            bits: bool,
        }
        impl TRCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBDR {
            bits: bool,
        }
        impl TRCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTZEROW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTLOADW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPAUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPADW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBUW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&self) -> TRCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTZEROR { bits }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&self) -> TRCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTLOADR { bits }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&self) -> TRCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPAUR { bits }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&self) -> TRCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPADR { bits }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&self) -> TRCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBUR { bits }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&self) -> TRCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&mut self) -> _TRCNTZEROW {
                _TRCNTZEROW { w: self }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&mut self) -> _TRCNTLOADW {
                _TRCNTLOADW { w: self }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&mut self) -> _TRCMPAUW {
                _TRCMPAUW { w: self }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&mut self) -> _TRCMPADW {
                _TRCMPADW { w: self }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&mut self) -> _TRCMPBUW {
                _TRCMPBUW { w: self }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&mut self) -> _TRCMPBDW {
                _TRCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM1 Raw Interrupt Status"]
    pub struct _1_RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Raw Interrupt Status"]
    pub mod _1_ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_1_RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt Status"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt Status"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt Status"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt Status"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt Status"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt Status"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
    }
    #[doc = "PWM1 Interrupt Status and Clear"]
    pub struct _1_ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Interrupt Status and Clear"]
    pub mod _1_isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM1 Load"]
    pub struct _1_LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Load"]
    pub mod _1_load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADR {
            bits: u16,
        }
        impl LOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&self) -> LOADR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                LOADR { bits }
            }
        }
        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 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&mut self) -> _LOADW {
                _LOADW { w: self }
            }
        }
    }
    #[doc = "PWM1 Counter"]
    pub struct _1_COUNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Counter"]
    pub mod _1_count {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_1_COUNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Value"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "PWM1 Compare A"]
    pub struct _1_CMPA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Compare A"]
    pub mod _1_cmpa {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_CMPA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPAR {
            bits: u16,
        }
        impl COMPAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&self) -> COMPAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPAR { bits }
            }
        }
        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 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&mut self) -> _COMPAW {
                _COMPAW { w: self }
            }
        }
    }
    #[doc = "PWM1 Compare B"]
    pub struct _1_CMPB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Compare B"]
    pub mod _1_cmpb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_CMPB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPBR {
            bits: u16,
        }
        impl COMPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPBW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&self) -> COMPBR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPBR { bits }
            }
        }
        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 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&mut self) -> _COMPBW {
                _COMPBW { w: self }
            }
        }
    }
    #[doc = "PWM1 Generator A Control"]
    pub struct _1_GENA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Generator A Control"]
    pub mod _1_gena {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_GENA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM1 Generator B Control"]
    pub struct _1_GENB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Generator B Control"]
    pub mod _1_genb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_GENB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM1 Dead-Band Control"]
    pub struct _1_DBCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Dead-Band Control"]
    pub mod _1_dbctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_DBCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
        }
        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 = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
        }
    }
    #[doc = "PWM1 Dead-Band Rising-Edge Delay"]
    pub struct _1_DBRISE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Dead-Band Rising-Edge Delay"]
    pub mod _1_dbrise {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_DBRISE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RISEDELAYR {
            bits: u16,
        }
        impl RISEDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RISEDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RISEDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&self) -> RISEDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RISEDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&mut self) -> _RISEDELAYW {
                _RISEDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM1 Dead-Band Falling-Edge-Delay"]
    pub struct _1_DBFALL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Dead-Band Falling-Edge-Delay"]
    pub mod _1_dbfall {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_DBFALL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FALLDELAYR {
            bits: u16,
        }
        impl FALLDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FALLDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FALLDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&self) -> FALLDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                FALLDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&mut self) -> _FALLDELAYW {
                _FALLDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM1 Fault Source 0"]
    pub struct _1_FLTSRC0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Fault Source 0"]
    pub mod _1_fltsrc0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_FLTSRC0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM1 Fault Source 1"]
    pub struct _1_FLTSRC1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Fault Source 1"]
    pub mod _1_fltsrc1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_FLTSRC1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM1 Minimum Fault Period"]
    pub struct _1_MINFLTPER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Minimum Fault Period"]
    pub mod _1_minfltper {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_MINFLTPER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MFPR {
            bits: u16,
        }
        impl MFPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MFPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MFPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&self) -> MFPR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MFPR { bits }
            }
        }
        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 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&mut self) -> _MFPW {
                _MFPW { w: self }
            }
        }
    }
    #[doc = "PWM2 Control"]
    pub struct _2_CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Control"]
    pub mod _2_ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DEBUGR {
            bits: bool,
        }
        impl DEBUGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADUPDR {
            bits: bool,
        }
        impl LOADUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPAUPDR {
            bits: bool,
        }
        impl CMPAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPBUPDR {
            bits: bool,
        }
        impl CMPBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `GENAUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENAUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENAUPDR::I => 0,
                    GENAUPDR::LS => 0x02,
                    GENAUPDR::GS => 0x03,
                    GENAUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENAUPDR {
                match value {
                    0 => GENAUPDR::I,
                    2 => GENAUPDR::LS,
                    3 => GENAUPDR::GS,
                    i => GENAUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENAUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENAUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENAUPDR::GS
            }
        }
        #[doc = "Possible values of the field `GENBUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENBUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENBUPDR::I => 0,
                    GENBUPDR::LS => 0x02,
                    GENBUPDR::GS => 0x03,
                    GENBUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENBUPDR {
                match value {
                    0 => GENBUPDR::I,
                    2 => GENBUPDR::LS,
                    3 => GENBUPDR::GS,
                    i => GENBUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENBUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENBUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENBUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBCTLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBCTLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBCTLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBCTLUPDR::I => 0,
                    DBCTLUPDR::LS => 0x02,
                    DBCTLUPDR::GS => 0x03,
                    DBCTLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBCTLUPDR {
                match value {
                    0 => DBCTLUPDR::I,
                    2 => DBCTLUPDR::LS,
                    3 => DBCTLUPDR::GS,
                    i => DBCTLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBCTLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBCTLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBCTLUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBRISEUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBRISEUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBRISEUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBRISEUPDR::I => 0,
                    DBRISEUPDR::LS => 0x02,
                    DBRISEUPDR::GS => 0x03,
                    DBRISEUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBRISEUPDR {
                match value {
                    0 => DBRISEUPDR::I,
                    2 => DBRISEUPDR::LS,
                    3 => DBRISEUPDR::GS,
                    i => DBRISEUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBRISEUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBRISEUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBRISEUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBFALLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBFALLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBFALLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBFALLUPDR::I => 0,
                    DBFALLUPDR::LS => 0x02,
                    DBFALLUPDR::GS => 0x03,
                    DBFALLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBFALLUPDR {
                match value {
                    0 => DBFALLUPDR::I,
                    2 => DBFALLUPDR::LS,
                    3 => DBFALLUPDR::GS,
                    i => DBFALLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBFALLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBFALLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBFALLUPDR::GS
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLTSRCR {
            bits: bool,
        }
        impl FLTSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINFLTPERR {
            bits: bool,
        }
        impl MINFLTPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LATCHR {
            bits: bool,
        }
        impl LATCHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEBUGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEBUGW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADUPDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPAUPDW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPBUPDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENAUPD`"]
        pub enum GENAUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENAUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENAUPDW::I => 0,
                    GENAUPDW::LS => 2,
                    GENAUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENAUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENAUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENAUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENAUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENAUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENBUPD`"]
        pub enum GENBUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENBUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENBUPDW::I => 0,
                    GENBUPDW::LS => 2,
                    GENBUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENBUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENBUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENBUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENBUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENBUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBCTLUPD`"]
        pub enum DBCTLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBCTLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBCTLUPDW::I => 0,
                    DBCTLUPDW::LS => 2,
                    DBCTLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBCTLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBCTLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBCTLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBCTLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBCTLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBCTLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBRISEUPD`"]
        pub enum DBRISEUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBRISEUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBRISEUPDW::I => 0,
                    DBRISEUPDW::LS => 2,
                    DBRISEUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBRISEUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBRISEUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBRISEUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBRISEUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBRISEUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBRISEUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBFALLUPD`"]
        pub enum DBFALLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBFALLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBFALLUPDW::I => 0,
                    DBFALLUPDW::LS => 2,
                    DBFALLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBFALLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBFALLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBFALLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBFALLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBFALLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBFALLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLTSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLTSRCW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINFLTPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINFLTPERW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LATCHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LATCHW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&self) -> DEBUGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DEBUGR { bits }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&self) -> LOADUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOADUPDR { bits }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&self) -> CMPAUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPAUPDR { bits }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&self) -> CMPBUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPBUPDR { bits }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&self) -> GENAUPDR {
                GENAUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&self) -> GENBUPDR {
                GENBUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&self) -> DBCTLUPDR {
                DBCTLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&self) -> DBRISEUPDR {
                DBRISEUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&self) -> DBFALLUPDR {
                DBFALLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&self) -> FLTSRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FLTSRCR { bits }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&self) -> MINFLTPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MINFLTPERR { bits }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&self) -> LATCHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LATCHR { bits }
            }
        }
        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 = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&mut self) -> _DEBUGW {
                _DEBUGW { w: self }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&mut self) -> _LOADUPDW {
                _LOADUPDW { w: self }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&mut self) -> _CMPAUPDW {
                _CMPAUPDW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&mut self) -> _CMPBUPDW {
                _CMPBUPDW { w: self }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&mut self) -> _GENAUPDW {
                _GENAUPDW { w: self }
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&mut self) -> _GENBUPDW {
                _GENBUPDW { w: self }
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&mut self) -> _DBCTLUPDW {
                _DBCTLUPDW { w: self }
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&mut self) -> _DBRISEUPDW {
                _DBRISEUPDW { w: self }
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&mut self) -> _DBFALLUPDW {
                _DBFALLUPDW { w: self }
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&mut self) -> _FLTSRCW {
                _FLTSRCW { w: self }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&mut self) -> _MINFLTPERW {
                _MINFLTPERW { w: self }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&mut self) -> _LATCHW {
                _LATCHW { w: self }
            }
        }
    }
    #[doc = "PWM2 Interrupt and Trigger Enable"]
    pub struct _2_INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Interrupt and Trigger Enable"]
    pub mod _2_inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTZEROR {
            bits: bool,
        }
        impl TRCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTLOADR {
            bits: bool,
        }
        impl TRCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPAUR {
            bits: bool,
        }
        impl TRCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPADR {
            bits: bool,
        }
        impl TRCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBUR {
            bits: bool,
        }
        impl TRCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBDR {
            bits: bool,
        }
        impl TRCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTZEROW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTLOADW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPAUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPADW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBUW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&self) -> TRCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTZEROR { bits }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&self) -> TRCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTLOADR { bits }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&self) -> TRCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPAUR { bits }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&self) -> TRCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPADR { bits }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&self) -> TRCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBUR { bits }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&self) -> TRCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&mut self) -> _TRCNTZEROW {
                _TRCNTZEROW { w: self }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&mut self) -> _TRCNTLOADW {
                _TRCNTLOADW { w: self }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&mut self) -> _TRCMPAUW {
                _TRCMPAUW { w: self }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&mut self) -> _TRCMPADW {
                _TRCMPADW { w: self }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&mut self) -> _TRCMPBUW {
                _TRCMPBUW { w: self }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&mut self) -> _TRCMPBDW {
                _TRCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM2 Raw Interrupt Status"]
    pub struct _2_RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Raw Interrupt Status"]
    pub mod _2_ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_2_RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt Status"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt Status"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt Status"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt Status"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt Status"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt Status"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
    }
    #[doc = "PWM2 Interrupt Status and Clear"]
    pub struct _2_ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Interrupt Status and Clear"]
    pub mod _2_isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM2 Load"]
    pub struct _2_LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Load"]
    pub mod _2_load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADR {
            bits: u16,
        }
        impl LOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&self) -> LOADR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                LOADR { bits }
            }
        }
        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 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&mut self) -> _LOADW {
                _LOADW { w: self }
            }
        }
    }
    #[doc = "PWM2 Counter"]
    pub struct _2_COUNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Counter"]
    pub mod _2_count {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_2_COUNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Value"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "PWM2 Compare A"]
    pub struct _2_CMPA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Compare A"]
    pub mod _2_cmpa {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_CMPA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPAR {
            bits: u16,
        }
        impl COMPAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&self) -> COMPAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPAR { bits }
            }
        }
        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 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&mut self) -> _COMPAW {
                _COMPAW { w: self }
            }
        }
    }
    #[doc = "PWM2 Compare B"]
    pub struct _2_CMPB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Compare B"]
    pub mod _2_cmpb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_CMPB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPBR {
            bits: u16,
        }
        impl COMPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPBW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&self) -> COMPBR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPBR { bits }
            }
        }
        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 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&mut self) -> _COMPBW {
                _COMPBW { w: self }
            }
        }
    }
    #[doc = "PWM2 Generator A Control"]
    pub struct _2_GENA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Generator A Control"]
    pub mod _2_gena {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_GENA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM2 Generator B Control"]
    pub struct _2_GENB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Generator B Control"]
    pub mod _2_genb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_GENB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM2 Dead-Band Control"]
    pub struct _2_DBCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Dead-Band Control"]
    pub mod _2_dbctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_DBCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
        }
        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 = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
        }
    }
    #[doc = "PWM2 Dead-Band Rising-Edge Delay"]
    pub struct _2_DBRISE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Dead-Band Rising-Edge Delay"]
    pub mod _2_dbrise {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_DBRISE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RISEDELAYR {
            bits: u16,
        }
        impl RISEDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RISEDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RISEDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&self) -> RISEDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RISEDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&mut self) -> _RISEDELAYW {
                _RISEDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM2 Dead-Band Falling-Edge-Delay"]
    pub struct _2_DBFALL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Dead-Band Falling-Edge-Delay"]
    pub mod _2_dbfall {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_DBFALL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FALLDELAYR {
            bits: u16,
        }
        impl FALLDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FALLDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FALLDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&self) -> FALLDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                FALLDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&mut self) -> _FALLDELAYW {
                _FALLDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM2 Fault Source 0"]
    pub struct _2_FLTSRC0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Fault Source 0"]
    pub mod _2_fltsrc0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_FLTSRC0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM2 Fault Source 1"]
    pub struct _2_FLTSRC1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Fault Source 1"]
    pub mod _2_fltsrc1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_FLTSRC1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM2 Minimum Fault Period"]
    pub struct _2_MINFLTPER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Minimum Fault Period"]
    pub mod _2_minfltper {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_MINFLTPER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MFPR {
            bits: u16,
        }
        impl MFPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MFPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MFPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&self) -> MFPR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MFPR { bits }
            }
        }
        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 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&mut self) -> _MFPW {
                _MFPW { w: self }
            }
        }
    }
    #[doc = "PWM3 Control"]
    pub struct _3_CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Control"]
    pub mod _3_ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DEBUGR {
            bits: bool,
        }
        impl DEBUGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADUPDR {
            bits: bool,
        }
        impl LOADUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPAUPDR {
            bits: bool,
        }
        impl CMPAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMPBUPDR {
            bits: bool,
        }
        impl CMPBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `GENAUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENAUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENAUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENAUPDR::I => 0,
                    GENAUPDR::LS => 0x02,
                    GENAUPDR::GS => 0x03,
                    GENAUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENAUPDR {
                match value {
                    0 => GENAUPDR::I,
                    2 => GENAUPDR::LS,
                    3 => GENAUPDR::GS,
                    i => GENAUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENAUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENAUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENAUPDR::GS
            }
        }
        #[doc = "Possible values of the field `GENBUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum GENBUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl GENBUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    GENBUPDR::I => 0,
                    GENBUPDR::LS => 0x02,
                    GENBUPDR::GS => 0x03,
                    GENBUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> GENBUPDR {
                match value {
                    0 => GENBUPDR::I,
                    2 => GENBUPDR::LS,
                    3 => GENBUPDR::GS,
                    i => GENBUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == GENBUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == GENBUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == GENBUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBCTLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBCTLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBCTLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBCTLUPDR::I => 0,
                    DBCTLUPDR::LS => 0x02,
                    DBCTLUPDR::GS => 0x03,
                    DBCTLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBCTLUPDR {
                match value {
                    0 => DBCTLUPDR::I,
                    2 => DBCTLUPDR::LS,
                    3 => DBCTLUPDR::GS,
                    i => DBCTLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBCTLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBCTLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBCTLUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBRISEUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBRISEUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBRISEUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBRISEUPDR::I => 0,
                    DBRISEUPDR::LS => 0x02,
                    DBRISEUPDR::GS => 0x03,
                    DBRISEUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBRISEUPDR {
                match value {
                    0 => DBRISEUPDR::I,
                    2 => DBRISEUPDR::LS,
                    3 => DBRISEUPDR::GS,
                    i => DBRISEUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBRISEUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBRISEUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBRISEUPDR::GS
            }
        }
        #[doc = "Possible values of the field `DBFALLUPD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DBFALLUPDR {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DBFALLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DBFALLUPDR::I => 0,
                    DBFALLUPDR::LS => 0x02,
                    DBFALLUPDR::GS => 0x03,
                    DBFALLUPDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DBFALLUPDR {
                match value {
                    0 => DBFALLUPDR::I,
                    2 => DBFALLUPDR::LS,
                    3 => DBFALLUPDR::GS,
                    i => DBFALLUPDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == DBFALLUPDR::I
            }
            #[doc = "Checks if the value of the field is `LS`"]
            #[inline]
            pub fn is_ls(&self) -> bool {
                *self == DBFALLUPDR::LS
            }
            #[doc = "Checks if the value of the field is `GS`"]
            #[inline]
            pub fn is_gs(&self) -> bool {
                *self == DBFALLUPDR::GS
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLTSRCR {
            bits: bool,
        }
        impl FLTSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINFLTPERR {
            bits: bool,
        }
        impl MINFLTPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LATCHR {
            bits: bool,
        }
        impl LATCHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEBUGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEBUGW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADUPDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPAUPDW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CMPBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CMPBUPDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENAUPD`"]
        pub enum GENAUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENAUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENAUPDW::I => 0,
                    GENAUPDW::LS => 2,
                    GENAUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENAUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENAUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENAUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENAUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENAUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENAUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `GENBUPD`"]
        pub enum GENBUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl GENBUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    GENBUPDW::I => 0,
                    GENBUPDW::LS => 2,
                    GENBUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _GENBUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GENBUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: GENBUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(GENBUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(GENBUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(GENBUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBCTLUPD`"]
        pub enum DBCTLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBCTLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBCTLUPDW::I => 0,
                    DBCTLUPDW::LS => 2,
                    DBCTLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBCTLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBCTLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBCTLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBCTLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBCTLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBCTLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBRISEUPD`"]
        pub enum DBRISEUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBRISEUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBRISEUPDW::I => 0,
                    DBRISEUPDW::LS => 2,
                    DBRISEUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBRISEUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBRISEUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBRISEUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBRISEUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBRISEUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBRISEUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DBFALLUPD`"]
        pub enum DBFALLUPDW {
            #[doc = "Immediate"]
            I,
            #[doc = "Locally Synchronized"]
            LS,
            #[doc = "Globally Synchronized"]
            GS,
        }
        impl DBFALLUPDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DBFALLUPDW::I => 0,
                    DBFALLUPDW::LS => 2,
                    DBFALLUPDW::GS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBFALLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBFALLUPDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DBFALLUPDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Immediate"]
            #[inline]
            pub fn i(self) -> &'a mut W {
                self.variant(DBFALLUPDW::I)
            }
            #[doc = "Locally Synchronized"]
            #[inline]
            pub fn ls(self) -> &'a mut W {
                self.variant(DBFALLUPDW::LS)
            }
            #[doc = "Globally Synchronized"]
            #[inline]
            pub fn gs(self) -> &'a mut W {
                self.variant(DBFALLUPDW::GS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLTSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLTSRCW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINFLTPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINFLTPERW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LATCHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LATCHW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&self) -> DEBUGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DEBUGR { bits }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&self) -> LOADUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOADUPDR { bits }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&self) -> CMPAUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPAUPDR { bits }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&self) -> CMPBUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMPBUPDR { bits }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&self) -> GENAUPDR {
                GENAUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&self) -> GENBUPDR {
                GENBUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&self) -> DBCTLUPDR {
                DBCTLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&self) -> DBRISEUPDR {
                DBRISEUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&self) -> DBFALLUPDR {
                DBFALLUPDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&self) -> FLTSRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FLTSRCR { bits }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&self) -> MINFLTPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MINFLTPERR { bits }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&self) -> LATCHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LATCHR { bits }
            }
        }
        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 = "Bit 0 - PWM Block Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - Counter Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 2 - Debug Mode"]
            #[inline]
            pub fn debug(&mut self) -> _DEBUGW {
                _DEBUGW { w: self }
            }
            #[doc = "Bit 3 - Load Register Update Mode"]
            #[inline]
            pub fn loadupd(&mut self) -> _LOADUPDW {
                _LOADUPDW { w: self }
            }
            #[doc = "Bit 4 - Comparator A Update Mode"]
            #[inline]
            pub fn cmpaupd(&mut self) -> _CMPAUPDW {
                _CMPAUPDW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Update Mode"]
            #[inline]
            pub fn cmpbupd(&mut self) -> _CMPBUPDW {
                _CMPBUPDW { w: self }
            }
            #[doc = "Bits 6:7 - PWMnGENA Update Mode"]
            #[inline]
            pub fn genaupd(&mut self) -> _GENAUPDW {
                _GENAUPDW { w: self }
            }
            #[doc = "Bits 8:9 - PWMnGENB Update Mode"]
            #[inline]
            pub fn genbupd(&mut self) -> _GENBUPDW {
                _GENBUPDW { w: self }
            }
            #[doc = "Bits 10:11 - PWMnDBCTL Update Mode"]
            #[inline]
            pub fn dbctlupd(&mut self) -> _DBCTLUPDW {
                _DBCTLUPDW { w: self }
            }
            #[doc = "Bits 12:13 - PWMnDBRISE Update Mode"]
            #[inline]
            pub fn dbriseupd(&mut self) -> _DBRISEUPDW {
                _DBRISEUPDW { w: self }
            }
            #[doc = "Bits 14:15 - PWMnDBFALL Update Mode"]
            #[inline]
            pub fn dbfallupd(&mut self) -> _DBFALLUPDW {
                _DBFALLUPDW { w: self }
            }
            #[doc = "Bit 16 - Fault Condition Source"]
            #[inline]
            pub fn fltsrc(&mut self) -> _FLTSRCW {
                _FLTSRCW { w: self }
            }
            #[doc = "Bit 17 - Minimum Fault Period"]
            #[inline]
            pub fn minfltper(&mut self) -> _MINFLTPERW {
                _MINFLTPERW { w: self }
            }
            #[doc = "Bit 18 - Latch Fault Input"]
            #[inline]
            pub fn latch(&mut self) -> _LATCHW {
                _LATCHW { w: self }
            }
        }
    }
    #[doc = "PWM3 Interrupt and Trigger Enable"]
    pub struct _3_INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Interrupt and Trigger Enable"]
    pub mod _3_inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTZEROR {
            bits: bool,
        }
        impl TRCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCNTLOADR {
            bits: bool,
        }
        impl TRCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPAUR {
            bits: bool,
        }
        impl TRCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPADR {
            bits: bool,
        }
        impl TRCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBUR {
            bits: bool,
        }
        impl TRCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRCMPBDR {
            bits: bool,
        }
        impl TRCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTZEROW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCNTLOADW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPAUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPADW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBUW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRCMPBDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&self) -> TRCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTZEROR { bits }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&self) -> TRCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCNTLOADR { bits }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&self) -> TRCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPAUR { bits }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&self) -> TRCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPADR { bits }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&self) -> TRCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBUR { bits }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&self) -> TRCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Interrupt for Counter=0"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Interrupt for Counter=PWMnLOAD"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Interrupt for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Interrupt for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Interrupt for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Interrupt for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
            #[doc = "Bit 8 - Trigger for Counter=0"]
            #[inline]
            pub fn trcntzero(&mut self) -> _TRCNTZEROW {
                _TRCNTZEROW { w: self }
            }
            #[doc = "Bit 9 - Trigger for Counter=PWMnLOAD"]
            #[inline]
            pub fn trcntload(&mut self) -> _TRCNTLOADW {
                _TRCNTLOADW { w: self }
            }
            #[doc = "Bit 10 - Trigger for Counter=PWMnCMPA Up"]
            #[inline]
            pub fn trcmpau(&mut self) -> _TRCMPAUW {
                _TRCMPAUW { w: self }
            }
            #[doc = "Bit 11 - Trigger for Counter=PWMnCMPA Down"]
            #[inline]
            pub fn trcmpad(&mut self) -> _TRCMPADW {
                _TRCMPADW { w: self }
            }
            #[doc = "Bit 12 - Trigger for Counter=PWMnCMPB Up"]
            #[inline]
            pub fn trcmpbu(&mut self) -> _TRCMPBUW {
                _TRCMPBUW { w: self }
            }
            #[doc = "Bit 13 - Trigger for Counter=PWMnCMPB Down"]
            #[inline]
            pub fn trcmpbd(&mut self) -> _TRCMPBDW {
                _TRCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM3 Raw Interrupt Status"]
    pub struct _3_RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Raw Interrupt Status"]
    pub mod _3_ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_3_RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt Status"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt Status"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt Status"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt Status"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt Status"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt Status"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
    }
    #[doc = "PWM3 Interrupt Status and Clear"]
    pub struct _3_ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Interrupt Status and Clear"]
    pub mod _3_isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTZEROR {
            bits: bool,
        }
        impl INTCNTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCNTLOADR {
            bits: bool,
        }
        impl INTCNTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPAUR {
            bits: bool,
        }
        impl INTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPADR {
            bits: bool,
        }
        impl INTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBUR {
            bits: bool,
        }
        impl INTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTCMPBDR {
            bits: bool,
        }
        impl INTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTZEROW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCNTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCNTLOADW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPAUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPADW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBUW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTCMPBDW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&self) -> INTCNTZEROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTZEROR { bits }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&self) -> INTCNTLOADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCNTLOADR { bits }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&self) -> INTCMPAUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPAUR { bits }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&self) -> INTCMPADR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPADR { bits }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&self) -> INTCMPBUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBUR { bits }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&self) -> INTCMPBDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTCMPBDR { bits }
            }
        }
        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 = "Bit 0 - Counter=0 Interrupt"]
            #[inline]
            pub fn intcntzero(&mut self) -> _INTCNTZEROW {
                _INTCNTZEROW { w: self }
            }
            #[doc = "Bit 1 - Counter=Load Interrupt"]
            #[inline]
            pub fn intcntload(&mut self) -> _INTCNTLOADW {
                _INTCNTLOADW { w: self }
            }
            #[doc = "Bit 2 - Comparator A Up Interrupt"]
            #[inline]
            pub fn intcmpau(&mut self) -> _INTCMPAUW {
                _INTCMPAUW { w: self }
            }
            #[doc = "Bit 3 - Comparator A Down Interrupt"]
            #[inline]
            pub fn intcmpad(&mut self) -> _INTCMPADW {
                _INTCMPADW { w: self }
            }
            #[doc = "Bit 4 - Comparator B Up Interrupt"]
            #[inline]
            pub fn intcmpbu(&mut self) -> _INTCMPBUW {
                _INTCMPBUW { w: self }
            }
            #[doc = "Bit 5 - Comparator B Down Interrupt"]
            #[inline]
            pub fn intcmpbd(&mut self) -> _INTCMPBDW {
                _INTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM3 Load"]
    pub struct _3_LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Load"]
    pub mod _3_load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOADR {
            bits: u16,
        }
        impl LOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&self) -> LOADR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                LOADR { bits }
            }
        }
        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 0:15 - Counter Load Value"]
            #[inline]
            pub fn load(&mut self) -> _LOADW {
                _LOADW { w: self }
            }
        }
    }
    #[doc = "PWM3 Counter"]
    pub struct _3_COUNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Counter"]
    pub mod _3_count {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::_3_COUNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Counter Value"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "PWM3 Compare A"]
    pub struct _3_CMPA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Compare A"]
    pub mod _3_cmpa {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_CMPA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPAR {
            bits: u16,
        }
        impl COMPAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&self) -> COMPAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPAR { bits }
            }
        }
        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 0:15 - Comparator A Value"]
            #[inline]
            pub fn compa(&mut self) -> _COMPAW {
                _COMPAW { w: self }
            }
        }
    }
    #[doc = "PWM3 Compare B"]
    pub struct _3_CMPB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Compare B"]
    pub mod _3_cmpb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_CMPB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMPBR {
            bits: u16,
        }
        impl COMPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMPBW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&self) -> COMPBR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMPBR { bits }
            }
        }
        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 0:15 - Comparator B Value"]
            #[inline]
            pub fn compb(&mut self) -> _COMPBW {
                _COMPBW { w: self }
            }
        }
    }
    #[doc = "PWM3 Generator A Control"]
    pub struct _3_GENA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Generator A Control"]
    pub mod _3_gena {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_GENA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmA"]
            INV,
            #[doc = "Drive pwmA Low"]
            ZERO,
            #[doc = "Drive pwmA High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmA"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmA Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmA High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM3 Generator B Control"]
    pub struct _3_GENB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Generator B Control"]
    pub mod _3_genb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_GENB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ACTZERO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTZEROR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTZEROR::NONE => 0,
                    ACTZEROR::INV => 0x01,
                    ACTZEROR::ZERO => 0x02,
                    ACTZEROR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTZEROR {
                match value {
                    0 => ACTZEROR::NONE,
                    1 => ACTZEROR::INV,
                    2 => ACTZEROR::ZERO,
                    3 => ACTZEROR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTZEROR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTZEROR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTZEROR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTZEROR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTLOAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTLOADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTLOADR::NONE => 0,
                    ACTLOADR::INV => 0x01,
                    ACTLOADR::ZERO => 0x02,
                    ACTLOADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTLOADR {
                match value {
                    0 => ACTLOADR::NONE,
                    1 => ACTLOADR::INV,
                    2 => ACTLOADR::ZERO,
                    3 => ACTLOADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTLOADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTLOADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTLOADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTLOADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPAUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPAUR::NONE => 0,
                    ACTCMPAUR::INV => 0x01,
                    ACTCMPAUR::ZERO => 0x02,
                    ACTCMPAUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPAUR {
                match value {
                    0 => ACTCMPAUR::NONE,
                    1 => ACTCMPAUR::INV,
                    2 => ACTCMPAUR::ZERO,
                    3 => ACTCMPAUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPAUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPAUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPAUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPAUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPAD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPADR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPADR::NONE => 0,
                    ACTCMPADR::INV => 0x01,
                    ACTCMPADR::ZERO => 0x02,
                    ACTCMPADR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPADR {
                match value {
                    0 => ACTCMPADR::NONE,
                    1 => ACTCMPADR::INV,
                    2 => ACTCMPADR::ZERO,
                    3 => ACTCMPADR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPADR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPADR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPADR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPADR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBU`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBUR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBUR::NONE => 0,
                    ACTCMPBUR::INV => 0x01,
                    ACTCMPBUR::ZERO => 0x02,
                    ACTCMPBUR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBUR {
                match value {
                    0 => ACTCMPBUR::NONE,
                    1 => ACTCMPBUR::INV,
                    2 => ACTCMPBUR::ZERO,
                    3 => ACTCMPBUR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBUR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBUR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBUR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBUR::ONE
            }
        }
        #[doc = "Possible values of the field `ACTCMPBD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ACTCMPBDR {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ACTCMPBDR::NONE => 0,
                    ACTCMPBDR::INV => 0x01,
                    ACTCMPBDR::ZERO => 0x02,
                    ACTCMPBDR::ONE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ACTCMPBDR {
                match value {
                    0 => ACTCMPBDR::NONE,
                    1 => ACTCMPBDR::INV,
                    2 => ACTCMPBDR::ZERO,
                    3 => ACTCMPBDR::ONE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ACTCMPBDR::NONE
            }
            #[doc = "Checks if the value of the field is `INV`"]
            #[inline]
            pub fn is_inv(&self) -> bool {
                *self == ACTCMPBDR::INV
            }
            #[doc = "Checks if the value of the field is `ZERO`"]
            #[inline]
            pub fn is_zero(&self) -> bool {
                *self == ACTCMPBDR::ZERO
            }
            #[doc = "Checks if the value of the field is `ONE`"]
            #[inline]
            pub fn is_one(&self) -> bool {
                *self == ACTCMPBDR::ONE
            }
        }
        #[doc = "Values that can be written to the field `ACTZERO`"]
        pub enum ACTZEROW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTZEROW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTZEROW::NONE => 0,
                    ACTZEROW::INV => 1,
                    ACTZEROW::ZERO => 2,
                    ACTZEROW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTZEROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTZEROW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTZEROW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTZEROW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTZEROW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTZEROW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTZEROW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTLOAD`"]
        pub enum ACTLOADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTLOADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTLOADW::NONE => 0,
                    ACTLOADW::INV => 1,
                    ACTLOADW::ZERO => 2,
                    ACTLOADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTLOADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTLOADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTLOADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTLOADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTLOADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTLOADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAU`"]
        pub enum ACTCMPAUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPAUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPAUW::NONE => 0,
                    ACTCMPAUW::INV => 1,
                    ACTCMPAUW::ZERO => 2,
                    ACTCMPAUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPAUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPAUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPAUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPAUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPAUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPAUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPAD`"]
        pub enum ACTCMPADW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPADW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPADW::NONE => 0,
                    ACTCMPADW::INV => 1,
                    ACTCMPADW::ZERO => 2,
                    ACTCMPADW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPADW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPADW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPADW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPADW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPADW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPADW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBU`"]
        pub enum ACTCMPBUW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBUW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBUW::NONE => 0,
                    ACTCMPBUW::INV => 1,
                    ACTCMPBUW::ZERO => 2,
                    ACTCMPBUW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBUW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBUW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBUW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBUW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBUW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ACTCMPBD`"]
        pub enum ACTCMPBDW {
            #[doc = "Do nothing"]
            NONE,
            #[doc = "Invert pwmB"]
            INV,
            #[doc = "Drive pwmB Low"]
            ZERO,
            #[doc = "Drive pwmB High"]
            ONE,
        }
        impl ACTCMPBDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ACTCMPBDW::NONE => 0,
                    ACTCMPBDW::INV => 1,
                    ACTCMPBDW::ZERO => 2,
                    ACTCMPBDW::ONE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACTCMPBDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACTCMPBDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ACTCMPBDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do nothing"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ACTCMPBDW::NONE)
            }
            #[doc = "Invert pwmB"]
            #[inline]
            pub fn inv(self) -> &'a mut W {
                self.variant(ACTCMPBDW::INV)
            }
            #[doc = "Drive pwmB Low"]
            #[inline]
            pub fn zero(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ZERO)
            }
            #[doc = "Drive pwmB High"]
            #[inline]
            pub fn one(self) -> &'a mut W {
                self.variant(ACTCMPBDW::ONE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&self) -> ACTZEROR {
                ACTZEROR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&self) -> ACTLOADR {
                ACTLOADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&self) -> ACTCMPAUR {
                ACTCMPAUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&self) -> ACTCMPADR {
                ACTCMPADR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&self) -> ACTCMPBUR {
                ACTCMPBUR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&self) -> ACTCMPBDR {
                ACTCMPBDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Action for Counter=0"]
            #[inline]
            pub fn actzero(&mut self) -> _ACTZEROW {
                _ACTZEROW { w: self }
            }
            #[doc = "Bits 2:3 - Action for Counter=LOAD"]
            #[inline]
            pub fn actload(&mut self) -> _ACTLOADW {
                _ACTLOADW { w: self }
            }
            #[doc = "Bits 4:5 - Action for Comparator A Up"]
            #[inline]
            pub fn actcmpau(&mut self) -> _ACTCMPAUW {
                _ACTCMPAUW { w: self }
            }
            #[doc = "Bits 6:7 - Action for Comparator A Down"]
            #[inline]
            pub fn actcmpad(&mut self) -> _ACTCMPADW {
                _ACTCMPADW { w: self }
            }
            #[doc = "Bits 8:9 - Action for Comparator B Up"]
            #[inline]
            pub fn actcmpbu(&mut self) -> _ACTCMPBUW {
                _ACTCMPBUW { w: self }
            }
            #[doc = "Bits 10:11 - Action for Comparator B Down"]
            #[inline]
            pub fn actcmpbd(&mut self) -> _ACTCMPBDW {
                _ACTCMPBDW { w: self }
            }
        }
    }
    #[doc = "PWM3 Dead-Band Control"]
    pub struct _3_DBCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Dead-Band Control"]
    pub mod _3_dbctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_DBCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
        }
        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 = "Bit 0 - Dead-Band Generator Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
        }
    }
    #[doc = "PWM3 Dead-Band Rising-Edge Delay"]
    pub struct _3_DBRISE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Dead-Band Rising-Edge Delay"]
    pub mod _3_dbrise {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_DBRISE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RISEDELAYR {
            bits: u16,
        }
        impl RISEDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RISEDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RISEDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&self) -> RISEDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RISEDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Rise Delay"]
            #[inline]
            pub fn risedelay(&mut self) -> _RISEDELAYW {
                _RISEDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM3 Dead-Band Falling-Edge-Delay"]
    pub struct _3_DBFALL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Dead-Band Falling-Edge-Delay"]
    pub mod _3_dbfall {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_DBFALL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FALLDELAYR {
            bits: u16,
        }
        impl FALLDELAYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FALLDELAYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FALLDELAYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&self) -> FALLDELAYR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                FALLDELAYR { bits }
            }
        }
        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 0:11 - Dead-Band Fall Delay"]
            #[inline]
            pub fn falldelay(&mut self) -> _FALLDELAYW {
                _FALLDELAYW { w: self }
            }
        }
    }
    #[doc = "PWM3 Fault Source 0"]
    pub struct _3_FLTSRC0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Fault Source 0"]
    pub mod _3_fltsrc0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_FLTSRC0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Input"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Input"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Input"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Input"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM3 Fault Source 1"]
    pub struct _3_FLTSRC1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Fault Source 1"]
    pub mod _3_fltsrc1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_FLTSRC1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM3 Minimum Fault Period"]
    pub struct _3_MINFLTPER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Minimum Fault Period"]
    pub mod _3_minfltper {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_MINFLTPER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MFPR {
            bits: u16,
        }
        impl MFPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MFPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MFPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&self) -> MFPR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MFPR { bits }
            }
        }
        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 0:15 - Minimum Fault Period"]
            #[inline]
            pub fn mfp(&mut self) -> _MFPW {
                _MFPW { w: self }
            }
        }
    }
    #[doc = "PWM0 Fault Pin Logic Sense"]
    pub struct _0_FLTSEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Fault Pin Logic Sense"]
    pub mod _0_fltsen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_FLTSEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM0 Fault Status 0"]
    pub struct _0_FLTSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Fault Status 0"]
    pub mod _0_fltstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_FLTSTAT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM0 Fault Status 1"]
    pub struct _0_FLTSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM0 Fault Status 1"]
    pub mod _0_fltstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_0_FLTSTAT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM1 Fault Pin Logic Sense"]
    pub struct _1_FLTSEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Fault Pin Logic Sense"]
    pub mod _1_fltsen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_FLTSEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM1 Fault Status 0"]
    pub struct _1_FLTSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Fault Status 0"]
    pub mod _1_fltstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_FLTSTAT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM1 Fault Status 1"]
    pub struct _1_FLTSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM1 Fault Status 1"]
    pub mod _1_fltstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_1_FLTSTAT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM2 Fault Pin Logic Sense"]
    pub struct _2_FLTSEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Fault Pin Logic Sense"]
    pub mod _2_fltsen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_FLTSEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM2 Fault Status 0"]
    pub struct _2_FLTSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Fault Status 0"]
    pub mod _2_fltstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_FLTSTAT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM2 Fault Status 1"]
    pub struct _2_FLTSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM2 Fault Status 1"]
    pub mod _2_fltstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_2_FLTSTAT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM3 Fault Pin Logic Sense"]
    pub struct _3_FLTSEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Fault Pin Logic Sense"]
    pub mod _3_fltsen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_FLTSEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault0 Sense"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault1 Sense"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault2 Sense"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault3 Sense"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM3 Fault Status 0"]
    pub struct _3_FLTSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Fault Status 0"]
    pub mod _3_fltstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_FLTSTAT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT0R {
            bits: bool,
        }
        impl FAULT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT1R {
            bits: bool,
        }
        impl FAULT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT2R {
            bits: bool,
        }
        impl FAULT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAULT3R {
            bits: bool,
        }
        impl FAULT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FAULT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FAULT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&self) -> FAULT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT0R { bits }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&self) -> FAULT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT1R { bits }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&self) -> FAULT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT2R { bits }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&self) -> FAULT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FAULT3R { bits }
            }
        }
        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 = "Bit 0 - Fault Input 0"]
            #[inline]
            pub fn fault0(&mut self) -> _FAULT0W {
                _FAULT0W { w: self }
            }
            #[doc = "Bit 1 - Fault Input 1"]
            #[inline]
            pub fn fault1(&mut self) -> _FAULT1W {
                _FAULT1W { w: self }
            }
            #[doc = "Bit 2 - Fault Input 2"]
            #[inline]
            pub fn fault2(&mut self) -> _FAULT2W {
                _FAULT2W { w: self }
            }
            #[doc = "Bit 3 - Fault Input 3"]
            #[inline]
            pub fn fault3(&mut self) -> _FAULT3W {
                _FAULT3W { w: self }
            }
        }
    }
    #[doc = "PWM3 Fault Status 1"]
    pub struct _3_FLTSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM3 Fault Status 1"]
    pub mod _3_fltstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::_3_FLTSTAT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP0R {
            bits: bool,
        }
        impl DCMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP1R {
            bits: bool,
        }
        impl DCMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP2R {
            bits: bool,
        }
        impl DCMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP3R {
            bits: bool,
        }
        impl DCMP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP4R {
            bits: bool,
        }
        impl DCMP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP5R {
            bits: bool,
        }
        impl DCMP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP6R {
            bits: bool,
        }
        impl DCMP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCMP7R {
            bits: bool,
        }
        impl DCMP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCMP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCMP7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&self) -> DCMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&self) -> DCMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&self) -> DCMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&self) -> DCMP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&self) -> DCMP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&self) -> DCMP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&self) -> DCMP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&self) -> DCMP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCMP7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0 Trigger"]
            #[inline]
            pub fn dcmp0(&mut self) -> _DCMP0W {
                _DCMP0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Trigger"]
            #[inline]
            pub fn dcmp1(&mut self) -> _DCMP1W {
                _DCMP1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Trigger"]
            #[inline]
            pub fn dcmp2(&mut self) -> _DCMP2W {
                _DCMP2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Trigger"]
            #[inline]
            pub fn dcmp3(&mut self) -> _DCMP3W {
                _DCMP3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Trigger"]
            #[inline]
            pub fn dcmp4(&mut self) -> _DCMP4W {
                _DCMP4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Trigger"]
            #[inline]
            pub fn dcmp5(&mut self) -> _DCMP5W {
                _DCMP5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Trigger"]
            #[inline]
            pub fn dcmp6(&mut self) -> _DCMP6W {
                _DCMP6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Trigger"]
            #[inline]
            pub fn dcmp7(&mut self) -> _DCMP7W {
                _DCMP7W { w: self }
            }
        }
    }
    #[doc = "PWM Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct GCNTR {
            bits: u8,
        }
        impl GCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FCNTR {
            bits: u8,
        }
        impl FCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ESYNCR {
            bits: bool,
        }
        impl ESYNCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EFAULTR {
            bits: bool,
        }
        impl EFAULTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ONER {
            bits: bool,
        }
        impl ONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Generators"]
            #[inline]
            pub fn gcnt(&self) -> GCNTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                GCNTR { bits }
            }
            #[doc = "Bits 4:7 - Fault Inputs (per PWM unit)"]
            #[inline]
            pub fn fcnt(&self) -> FCNTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FCNTR { bits }
            }
            #[doc = "Bit 8 - Extended Synchronization"]
            #[inline]
            pub fn esync(&self) -> ESYNCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ESYNCR { bits }
            }
            #[doc = "Bit 9 - Extended Fault"]
            #[inline]
            pub fn efault(&self) -> EFAULTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EFAULTR { bits }
            }
            #[doc = "Bit 10 - One-Shot Mode"]
            #[inline]
            pub fn one(&self) -> ONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ONER { bits }
            }
        }
    }
    #[doc = "PWM Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PWM Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PWMDIV`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PWMDIVR {
            #[doc = "/2"]
            _2,
            #[doc = "/4"]
            _4,
            #[doc = "/8"]
            _8,
            #[doc = "/16"]
            _16,
            #[doc = "/32"]
            _32,
            #[doc = "/64"]
            _64,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PWMDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PWMDIVR::_2 => 0,
                    PWMDIVR::_4 => 0x01,
                    PWMDIVR::_8 => 0x02,
                    PWMDIVR::_16 => 0x03,
                    PWMDIVR::_32 => 0x04,
                    PWMDIVR::_64 => 0x05,
                    PWMDIVR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PWMDIVR {
                match value {
                    0 => PWMDIVR::_2,
                    1 => PWMDIVR::_4,
                    2 => PWMDIVR::_8,
                    3 => PWMDIVR::_16,
                    4 => PWMDIVR::_32,
                    5 => PWMDIVR::_64,
                    i => PWMDIVR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == PWMDIVR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == PWMDIVR::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == PWMDIVR::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == PWMDIVR::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == PWMDIVR::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == PWMDIVR::_64
            }
        }
        #[doc = r" Value of the field"]
        pub struct USEPWMR {
            bits: bool,
        }
        impl USEPWMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `PWMDIV`"]
        pub enum PWMDIVW {
            #[doc = "/2"]
            _2,
            #[doc = "/4"]
            _4,
            #[doc = "/8"]
            _8,
            #[doc = "/16"]
            _16,
            #[doc = "/32"]
            _32,
            #[doc = "/64"]
            _64,
        }
        impl PWMDIVW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PWMDIVW::_2 => 0,
                    PWMDIVW::_4 => 1,
                    PWMDIVW::_8 => 2,
                    PWMDIVW::_16 => 3,
                    PWMDIVW::_32 => 4,
                    PWMDIVW::_64 => 5,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWMDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWMDIVW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PWMDIVW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "/2"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(PWMDIVW::_2)
            }
            #[doc = "/4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(PWMDIVW::_4)
            }
            #[doc = "/8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(PWMDIVW::_8)
            }
            #[doc = "/16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(PWMDIVW::_16)
            }
            #[doc = "/32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(PWMDIVW::_32)
            }
            #[doc = "/64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(PWMDIVW::_64)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _USEPWMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _USEPWMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - PWM Clock Divider"]
            #[inline]
            pub fn pwmdiv(&self) -> PWMDIVR {
                PWMDIVR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 8 - Use PWM Clock Divisor"]
            #[inline]
            pub fn usepwm(&self) -> USEPWMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                USEPWMR { bits }
            }
        }
        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 0:2 - PWM Clock Divider"]
            #[inline]
            pub fn pwmdiv(&mut self) -> _PWMDIVW {
                _PWMDIVW { w: self }
            }
            #[doc = "Bit 8 - Use PWM Clock Divisor"]
            #[inline]
            pub fn usepwm(&mut self) -> _USEPWMW {
                _USEPWMW { w: self }
            }
        }
    }
}
#[doc = "QEI register offsets"]
pub struct QEI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for QEI0 {}
impl QEI0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const qei0::RegisterBlock {
        0x4002_c000 as *const _
    }
}
impl Deref for QEI0 {
    type Target = qei0::RegisterBlock;
    fn deref(&self) -> &qei0::RegisterBlock {
        unsafe { &*QEI0::ptr() }
    }
}
#[doc = "QEI register offsets"]
pub mod qei0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - QEI Control"]
        pub ctl: CTL,
        #[doc = "0x04 - QEI Status"]
        pub stat: STAT,
        #[doc = "0x08 - QEI Position"]
        pub pos: POS,
        #[doc = "0x0c - QEI Maximum Position"]
        pub maxpos: MAXPOS,
        #[doc = "0x10 - QEI Timer Load"]
        pub load: LOAD,
        #[doc = "0x14 - QEI Timer"]
        pub time: TIME,
        #[doc = "0x18 - QEI Velocity Counter"]
        pub count: COUNT,
        #[doc = "0x1c - QEI Velocity"]
        pub speed: SPEED,
        #[doc = "0x20 - QEI Interrupt Enable"]
        pub inten: INTEN,
        #[doc = "0x24 - QEI Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x28 - QEI Interrupt Status and Clear"]
        pub isc: ISC,
    }
    #[doc = "QEI Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SWAPR {
            bits: bool,
        }
        impl SWAPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIGMODER {
            bits: bool,
        }
        impl SIGMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPMODER {
            bits: bool,
        }
        impl CAPMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESMODER {
            bits: bool,
        }
        impl RESMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VELENR {
            bits: bool,
        }
        impl VELENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `VELDIV`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VELDIVR {
            #[doc = "QEI clock /1"]
            _1,
            #[doc = "QEI clock /2"]
            _2,
            #[doc = "QEI clock /4"]
            _4,
            #[doc = "QEI clock /8"]
            _8,
            #[doc = "QEI clock /16"]
            _16,
            #[doc = "QEI clock /32"]
            _32,
            #[doc = "QEI clock /64"]
            _64,
            #[doc = "QEI clock /128"]
            _128,
        }
        impl VELDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VELDIVR::_1 => 0,
                    VELDIVR::_2 => 0x01,
                    VELDIVR::_4 => 0x02,
                    VELDIVR::_8 => 0x03,
                    VELDIVR::_16 => 0x04,
                    VELDIVR::_32 => 0x05,
                    VELDIVR::_64 => 0x06,
                    VELDIVR::_128 => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VELDIVR {
                match value {
                    0 => VELDIVR::_1,
                    1 => VELDIVR::_2,
                    2 => VELDIVR::_4,
                    3 => VELDIVR::_8,
                    4 => VELDIVR::_16,
                    5 => VELDIVR::_32,
                    6 => VELDIVR::_64,
                    7 => VELDIVR::_128,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == VELDIVR::_1
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == VELDIVR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == VELDIVR::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == VELDIVR::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == VELDIVR::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == VELDIVR::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == VELDIVR::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == VELDIVR::_128
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVAR {
            bits: bool,
        }
        impl INVAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVBR {
            bits: bool,
        }
        impl INVBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVIR {
            bits: bool,
        }
        impl INVIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLENR {
            bits: bool,
        }
        impl STALLENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FILTENR {
            bits: bool,
        }
        impl FILTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FILTCNTR {
            bits: u8,
        }
        impl FILTCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SWAPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SWAPW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIGMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIGMODEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPMODEW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESMODEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VELENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VELENW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `VELDIV`"]
        pub enum VELDIVW {
            #[doc = "QEI clock /1"]
            _1,
            #[doc = "QEI clock /2"]
            _2,
            #[doc = "QEI clock /4"]
            _4,
            #[doc = "QEI clock /8"]
            _8,
            #[doc = "QEI clock /16"]
            _16,
            #[doc = "QEI clock /32"]
            _32,
            #[doc = "QEI clock /64"]
            _64,
            #[doc = "QEI clock /128"]
            _128,
        }
        impl VELDIVW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VELDIVW::_1 => 0,
                    VELDIVW::_2 => 1,
                    VELDIVW::_4 => 2,
                    VELDIVW::_8 => 3,
                    VELDIVW::_16 => 4,
                    VELDIVW::_32 => 5,
                    VELDIVW::_64 => 6,
                    VELDIVW::_128 => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VELDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VELDIVW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VELDIVW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "QEI clock /1"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(VELDIVW::_1)
            }
            #[doc = "QEI clock /2"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(VELDIVW::_2)
            }
            #[doc = "QEI clock /4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(VELDIVW::_4)
            }
            #[doc = "QEI clock /8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(VELDIVW::_8)
            }
            #[doc = "QEI clock /16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(VELDIVW::_16)
            }
            #[doc = "QEI clock /32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(VELDIVW::_32)
            }
            #[doc = "QEI clock /64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(VELDIVW::_64)
            }
            #[doc = "QEI clock /128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(VELDIVW::_128)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INVAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INVAW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INVBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INVBW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INVIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INVIW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLENW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FILTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FILTENW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FILTCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FILTCNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Enable QEI"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - Swap Signals"]
            #[inline]
            pub fn swap(&self) -> SWAPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SWAPR { bits }
            }
            #[doc = "Bit 2 - Signal Mode"]
            #[inline]
            pub fn sigmode(&self) -> SIGMODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SIGMODER { bits }
            }
            #[doc = "Bit 3 - Capture Mode"]
            #[inline]
            pub fn capmode(&self) -> CAPMODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAPMODER { bits }
            }
            #[doc = "Bit 4 - Reset Mode"]
            #[inline]
            pub fn resmode(&self) -> RESMODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RESMODER { bits }
            }
            #[doc = "Bit 5 - Capture Velocity"]
            #[inline]
            pub fn velen(&self) -> VELENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VELENR { bits }
            }
            #[doc = "Bits 6:8 - Predivide Velocity"]
            #[inline]
            pub fn veldiv(&self) -> VELDIVR {
                VELDIVR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 9 - Invert PhA"]
            #[inline]
            pub fn inva(&self) -> INVAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVAR { bits }
            }
            #[doc = "Bit 10 - Invert PhB"]
            #[inline]
            pub fn invb(&self) -> INVBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVBR { bits }
            }
            #[doc = "Bit 11 - Invert Index Pulse"]
            #[inline]
            pub fn invi(&self) -> INVIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVIR { bits }
            }
            #[doc = "Bit 12 - Stall QEI"]
            #[inline]
            pub fn stallen(&self) -> STALLENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STALLENR { bits }
            }
            #[doc = "Bit 13 - Enable Input Filter"]
            #[inline]
            pub fn filten(&self) -> FILTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FILTENR { bits }
            }
            #[doc = "Bits 16:19 - Input Filter Prescale Count"]
            #[inline]
            pub fn filtcnt(&self) -> FILTCNTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FILTCNTR { bits }
            }
        }
        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 = "Bit 0 - Enable QEI"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - Swap Signals"]
            #[inline]
            pub fn swap(&mut self) -> _SWAPW {
                _SWAPW { w: self }
            }
            #[doc = "Bit 2 - Signal Mode"]
            #[inline]
            pub fn sigmode(&mut self) -> _SIGMODEW {
                _SIGMODEW { w: self }
            }
            #[doc = "Bit 3 - Capture Mode"]
            #[inline]
            pub fn capmode(&mut self) -> _CAPMODEW {
                _CAPMODEW { w: self }
            }
            #[doc = "Bit 4 - Reset Mode"]
            #[inline]
            pub fn resmode(&mut self) -> _RESMODEW {
                _RESMODEW { w: self }
            }
            #[doc = "Bit 5 - Capture Velocity"]
            #[inline]
            pub fn velen(&mut self) -> _VELENW {
                _VELENW { w: self }
            }
            #[doc = "Bits 6:8 - Predivide Velocity"]
            #[inline]
            pub fn veldiv(&mut self) -> _VELDIVW {
                _VELDIVW { w: self }
            }
            #[doc = "Bit 9 - Invert PhA"]
            #[inline]
            pub fn inva(&mut self) -> _INVAW {
                _INVAW { w: self }
            }
            #[doc = "Bit 10 - Invert PhB"]
            #[inline]
            pub fn invb(&mut self) -> _INVBW {
                _INVBW { w: self }
            }
            #[doc = "Bit 11 - Invert Index Pulse"]
            #[inline]
            pub fn invi(&mut self) -> _INVIW {
                _INVIW { w: self }
            }
            #[doc = "Bit 12 - Stall QEI"]
            #[inline]
            pub fn stallen(&mut self) -> _STALLENW {
                _STALLENW { w: self }
            }
            #[doc = "Bit 13 - Enable Input Filter"]
            #[inline]
            pub fn filten(&mut self) -> _FILTENW {
                _FILTENW { w: self }
            }
            #[doc = "Bits 16:19 - Input Filter Prescale Count"]
            #[inline]
            pub fn filtcnt(&mut self) -> _FILTCNTW {
                _FILTCNTW { w: self }
            }
        }
    }
    #[doc = "QEI Status"]
    pub struct STAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Status"]
    pub mod stat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::STAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRECTIONR {
            bits: bool,
        }
        impl DIRECTIONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Error Detected"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 1 - Direction of Rotation"]
            #[inline]
            pub fn direction(&self) -> DIRECTIONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRECTIONR { bits }
            }
        }
    }
    #[doc = "QEI Position"]
    pub struct POS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Position"]
    pub mod pos {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::POS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "QEI Maximum Position"]
    pub struct MAXPOS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Maximum Position"]
    pub mod maxpos {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MAXPOS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "QEI Timer Load"]
    pub struct LOAD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Timer Load"]
    pub mod load {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LOAD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "QEI Timer"]
    pub struct TIME {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Timer"]
    pub mod time {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TIME {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "QEI Velocity Counter"]
    pub struct COUNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Velocity Counter"]
    pub mod count {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::COUNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "QEI Velocity"]
    pub struct SPEED {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Velocity"]
    pub mod speed {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SPEED {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "QEI Interrupt Enable"]
    pub struct INTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Interrupt Enable"]
    pub mod inten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::INTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INDEXR {
            bits: bool,
        }
        impl INDEXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMERR {
            bits: bool,
        }
        impl TIMERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INDEXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INDEXW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TIMERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TIMERW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Index Pulse Detected Interrupt Enable"]
            #[inline]
            pub fn index(&self) -> INDEXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INDEXR { bits }
            }
            #[doc = "Bit 1 - Timer Expires Interrupt Enable"]
            #[inline]
            pub fn timer(&self) -> TIMERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TIMERR { bits }
            }
            #[doc = "Bit 2 - Direction Change Interrupt Enable"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 3 - Phase Error Interrupt Enable"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRORR { bits }
            }
        }
        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 = "Bit 0 - Index Pulse Detected Interrupt Enable"]
            #[inline]
            pub fn index(&mut self) -> _INDEXW {
                _INDEXW { w: self }
            }
            #[doc = "Bit 1 - Timer Expires Interrupt Enable"]
            #[inline]
            pub fn timer(&mut self) -> _TIMERW {
                _TIMERW { w: self }
            }
            #[doc = "Bit 2 - Direction Change Interrupt Enable"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 3 - Phase Error Interrupt Enable"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
        }
    }
    #[doc = "QEI Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INDEXR {
            bits: bool,
        }
        impl INDEXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMERR {
            bits: bool,
        }
        impl TIMERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Index Pulse Asserted"]
            #[inline]
            pub fn index(&self) -> INDEXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INDEXR { bits }
            }
            #[doc = "Bit 1 - Velocity Timer Expired"]
            #[inline]
            pub fn timer(&self) -> TIMERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TIMERR { bits }
            }
            #[doc = "Bit 2 - Direction Change Detected"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 3 - Phase Error Detected"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRORR { bits }
            }
        }
    }
    #[doc = "QEI Interrupt Status and Clear"]
    pub struct ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "QEI Interrupt Status and Clear"]
    pub mod isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INDEXR {
            bits: bool,
        }
        impl INDEXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMERR {
            bits: bool,
        }
        impl TIMERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INDEXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INDEXW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TIMERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TIMERW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Index Pulse Interrupt"]
            #[inline]
            pub fn index(&self) -> INDEXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INDEXR { bits }
            }
            #[doc = "Bit 1 - Velocity Timer Expired Interrupt"]
            #[inline]
            pub fn timer(&self) -> TIMERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TIMERR { bits }
            }
            #[doc = "Bit 2 - Direction Change Interrupt"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 3 - Phase Error Interrupt"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRORR { bits }
            }
        }
        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 = "Bit 0 - Index Pulse Interrupt"]
            #[inline]
            pub fn index(&mut self) -> _INDEXW {
                _INDEXW { w: self }
            }
            #[doc = "Bit 1 - Velocity Timer Expired Interrupt"]
            #[inline]
            pub fn timer(&mut self) -> _TIMERW {
                _TIMERW { w: self }
            }
            #[doc = "Bit 2 - Direction Change Interrupt"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 3 - Phase Error Interrupt"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
        }
    }
}
#[doc = "Timer register offsets"]
pub struct TIMER0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER0 {}
impl TIMER0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_0000 as *const _
    }
}
impl Deref for TIMER0 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER0::ptr() }
    }
}
#[doc = "Timer register offsets"]
pub mod timer0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - GPTM Configuration"]
        pub cfg: CFG,
        #[doc = "0x04 - GPTM Timer A Mode"]
        pub tamr: TAMR,
        #[doc = "0x08 - GPTM Timer B Mode"]
        pub tbmr: TBMR,
        #[doc = "0x0c - GPTM Control"]
        pub ctl: CTL,
        #[doc = "0x10 - GPTM Synchronize"]
        pub sync: SYNC,
        _reserved0: [u8; 4usize],
        #[doc = "0x18 - GPTM Interrupt Mask"]
        pub imr: IMR,
        #[doc = "0x1c - GPTM Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x20 - GPTM Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x24 - GPTM Interrupt Clear"]
        pub icr: ICR,
        #[doc = "0x28 - GPTM Timer A Interval Load"]
        pub tailr: TAILR,
        #[doc = "0x2c - GPTM Timer B Interval Load"]
        pub tbilr: TBILR,
        #[doc = "0x30 - GPTM Timer A Match"]
        pub tamatchr: TAMATCHR,
        #[doc = "0x34 - GPTM Timer B Match"]
        pub tbmatchr: TBMATCHR,
        #[doc = "0x38 - GPTM Timer A Prescale"]
        pub tapr: TAPR,
        #[doc = "0x3c - GPTM Timer B Prescale"]
        pub tbpr: TBPR,
        #[doc = "0x40 - GPTM TimerA Prescale Match"]
        pub tapmr: TAPMR,
        #[doc = "0x44 - GPTM TimerB Prescale Match"]
        pub tbpmr: TBPMR,
        #[doc = "0x48 - GPTM Timer A"]
        pub tar: TAR,
        #[doc = "0x4c - GPTM Timer B"]
        pub tbr: TBR,
        #[doc = "0x50 - GPTM Timer A Value"]
        pub tav: TAV,
        #[doc = "0x54 - GPTM Timer B Value"]
        pub tbv: TBV,
        #[doc = "0x58 - GPTM RTC Predivide"]
        pub rtcpd: RTCPD,
        #[doc = "0x5c - GPTM Timer A Prescale Snapshot"]
        pub taps: TAPS,
        #[doc = "0x60 - GPTM Timer B Prescale Snapshot"]
        pub tbps: TBPS,
        _reserved1: [u8; 8usize],
        #[doc = "0x6c - GPTM DMA Event"]
        pub dmaev: DMAEV,
        #[doc = "0x70 - GPTM ADC Event"]
        pub adcev: ADCEV,
        _reserved2: [u8; 3916usize],
        #[doc = "0xfc0 - GPTM Peripheral Properties"]
        pub pp: PP,
        _reserved3: [u8; 4usize],
        #[doc = "0xfc8 - GPTM Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "GPTM Configuration"]
    pub struct CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Configuration"]
    pub mod cfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CFG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CFGR {
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit timer configuration"]
            _32_BIT_TIMER,
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit real-time clock (RTC) counter configuration"]
            _32_BIT_RTC,
            #[doc = "For a 16/32-bit timer, this value selects the 16-bit timer configuration"]
            _16_BIT,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CFGR::_32_BIT_TIMER => 0,
                    CFGR::_32_BIT_RTC => 0x01,
                    CFGR::_16_BIT => 0x04,
                    CFGR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CFGR {
                match value {
                    0 => CFGR::_32_BIT_TIMER,
                    1 => CFGR::_32_BIT_RTC,
                    4 => CFGR::_16_BIT,
                    i => CFGR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_32_BIT_TIMER`"]
            #[inline]
            pub fn is_32_bit_timer(&self) -> bool {
                *self == CFGR::_32_BIT_TIMER
            }
            #[doc = "Checks if the value of the field is `_32_BIT_RTC`"]
            #[inline]
            pub fn is_32_bit_rtc(&self) -> bool {
                *self == CFGR::_32_BIT_RTC
            }
            #[doc = "Checks if the value of the field is `_16_BIT`"]
            #[inline]
            pub fn is_16_bit(&self) -> bool {
                *self == CFGR::_16_BIT
            }
        }
        #[doc = "Values that can be written to the field `CFG`"]
        pub enum CFGW {
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit timer configuration"]
            _32_BIT_TIMER,
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit real-time clock (RTC) counter configuration"]
            _32_BIT_RTC,
            #[doc = "For a 16/32-bit timer, this value selects the 16-bit timer configuration"]
            _16_BIT,
        }
        impl CFGW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CFGW::_32_BIT_TIMER => 0,
                    CFGW::_32_BIT_RTC => 1,
                    CFGW::_16_BIT => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CFGW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CFGW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit timer configuration"]
            #[inline]
            pub fn _32_bit_timer(self) -> &'a mut W {
                self.variant(CFGW::_32_BIT_TIMER)
            }
            #[doc = "For a 16/32-bit timer, this value selects the 32-bit real-time clock (RTC) counter configuration"]
            #[inline]
            pub fn _32_bit_rtc(self) -> &'a mut W {
                self.variant(CFGW::_32_BIT_RTC)
            }
            #[doc = "For a 16/32-bit timer, this value selects the 16-bit timer configuration"]
            #[inline]
            pub fn _16_bit(self) -> &'a mut W {
                self.variant(CFGW::_16_BIT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - GPTM Configuration"]
            #[inline]
            pub fn cfg(&self) -> CFGR {
                CFGR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:2 - GPTM Configuration"]
            #[inline]
            pub fn cfg(&mut self) -> _CFGW {
                _CFGW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer A Mode"]
    pub struct TAMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Mode"]
    pub mod tamr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `TAMR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TAMRR {
            #[doc = "One-Shot Timer mode"]
            _1_SHOT,
            #[doc = "Periodic Timer mode"]
            PERIOD,
            #[doc = "Capture mode"]
            CAP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TAMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TAMRR::_1_SHOT => 0x01,
                    TAMRR::PERIOD => 0x02,
                    TAMRR::CAP => 0x03,
                    TAMRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TAMRR {
                match value {
                    1 => TAMRR::_1_SHOT,
                    2 => TAMRR::PERIOD,
                    3 => TAMRR::CAP,
                    i => TAMRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1_SHOT`"]
            #[inline]
            pub fn is_1_shot(&self) -> bool {
                *self == TAMRR::_1_SHOT
            }
            #[doc = "Checks if the value of the field is `PERIOD`"]
            #[inline]
            pub fn is_period(&self) -> bool {
                *self == TAMRR::PERIOD
            }
            #[doc = "Checks if the value of the field is `CAP`"]
            #[inline]
            pub fn is_cap(&self) -> bool {
                *self == TAMRR::CAP
            }
        }
        #[doc = r" Value of the field"]
        pub struct TACMRR {
            bits: bool,
        }
        impl TACMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAAMSR {
            bits: bool,
        }
        impl TAAMSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TACDIRR {
            bits: bool,
        }
        impl TACDIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMIER {
            bits: bool,
        }
        impl TAMIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAWOTR {
            bits: bool,
        }
        impl TAWOTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TASNAPSR {
            bits: bool,
        }
        impl TASNAPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAILDR {
            bits: bool,
        }
        impl TAILDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAPWMIER {
            bits: bool,
        }
        impl TAPWMIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMRSUR {
            bits: bool,
        }
        impl TAMRSUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAPLOR {
            bits: bool,
        }
        impl TAPLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TACINTDR {
            bits: bool,
        }
        impl TACINTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TCACT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TCACTR {
            #[doc = "Disable compare operations"]
            NONE,
            #[doc = "Toggle State on Time-Out"]
            TOGGLE,
            #[doc = "Clear CCP on Time-Out"]
            CLRTO,
            #[doc = "Set CCP on Time-Out"]
            SETTO,
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            SETTOGTO,
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            CLRTOGTO,
            #[doc = "Set CCP immediately and clear on Time-Out"]
            SETCLRTO,
            #[doc = "Clear CCP immediately and set on Time-Out"]
            CLRSETTO,
        }
        impl TCACTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TCACTR::NONE => 0,
                    TCACTR::TOGGLE => 0x01,
                    TCACTR::CLRTO => 0x02,
                    TCACTR::SETTO => 0x03,
                    TCACTR::SETTOGTO => 0x04,
                    TCACTR::CLRTOGTO => 0x05,
                    TCACTR::SETCLRTO => 0x06,
                    TCACTR::CLRSETTO => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TCACTR {
                match value {
                    0 => TCACTR::NONE,
                    1 => TCACTR::TOGGLE,
                    2 => TCACTR::CLRTO,
                    3 => TCACTR::SETTO,
                    4 => TCACTR::SETTOGTO,
                    5 => TCACTR::CLRTOGTO,
                    6 => TCACTR::SETCLRTO,
                    7 => TCACTR::CLRSETTO,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == TCACTR::NONE
            }
            #[doc = "Checks if the value of the field is `TOGGLE`"]
            #[inline]
            pub fn is_toggle(&self) -> bool {
                *self == TCACTR::TOGGLE
            }
            #[doc = "Checks if the value of the field is `CLRTO`"]
            #[inline]
            pub fn is_clrto(&self) -> bool {
                *self == TCACTR::CLRTO
            }
            #[doc = "Checks if the value of the field is `SETTO`"]
            #[inline]
            pub fn is_setto(&self) -> bool {
                *self == TCACTR::SETTO
            }
            #[doc = "Checks if the value of the field is `SETTOGTO`"]
            #[inline]
            pub fn is_settogto(&self) -> bool {
                *self == TCACTR::SETTOGTO
            }
            #[doc = "Checks if the value of the field is `CLRTOGTO`"]
            #[inline]
            pub fn is_clrtogto(&self) -> bool {
                *self == TCACTR::CLRTOGTO
            }
            #[doc = "Checks if the value of the field is `SETCLRTO`"]
            #[inline]
            pub fn is_setclrto(&self) -> bool {
                *self == TCACTR::SETCLRTO
            }
            #[doc = "Checks if the value of the field is `CLRSETTO`"]
            #[inline]
            pub fn is_clrsetto(&self) -> bool {
                *self == TCACTR::CLRSETTO
            }
        }
        #[doc = "Values that can be written to the field `TAMR`"]
        pub enum TAMRW {
            #[doc = "One-Shot Timer mode"]
            _1_SHOT,
            #[doc = "Periodic Timer mode"]
            PERIOD,
            #[doc = "Capture mode"]
            CAP,
        }
        impl TAMRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TAMRW::_1_SHOT => 1,
                    TAMRW::PERIOD => 2,
                    TAMRW::CAP => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TAMRW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "One-Shot Timer mode"]
            #[inline]
            pub fn _1_shot(self) -> &'a mut W {
                self.variant(TAMRW::_1_SHOT)
            }
            #[doc = "Periodic Timer mode"]
            #[inline]
            pub fn period(self) -> &'a mut W {
                self.variant(TAMRW::PERIOD)
            }
            #[doc = "Capture mode"]
            #[inline]
            pub fn cap(self) -> &'a mut W {
                self.variant(TAMRW::CAP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TACMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TACMRW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAAMSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAAMSW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TACDIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TACDIRW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMIEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAWOTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAWOTW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TASNAPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TASNAPSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAILDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAILDW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAPWMIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAPWMIEW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMRSUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMRSUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAPLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAPLOW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TACINTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TACINTDW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TCACT`"]
        pub enum TCACTW {
            #[doc = "Disable compare operations"]
            NONE,
            #[doc = "Toggle State on Time-Out"]
            TOGGLE,
            #[doc = "Clear CCP on Time-Out"]
            CLRTO,
            #[doc = "Set CCP on Time-Out"]
            SETTO,
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            SETTOGTO,
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            CLRTOGTO,
            #[doc = "Set CCP immediately and clear on Time-Out"]
            SETCLRTO,
            #[doc = "Clear CCP immediately and set on Time-Out"]
            CLRSETTO,
        }
        impl TCACTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TCACTW::NONE => 0,
                    TCACTW::TOGGLE => 1,
                    TCACTW::CLRTO => 2,
                    TCACTW::SETTO => 3,
                    TCACTW::SETTOGTO => 4,
                    TCACTW::CLRTOGTO => 5,
                    TCACTW::SETCLRTO => 6,
                    TCACTW::CLRSETTO => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TCACTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TCACTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TCACTW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Disable compare operations"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(TCACTW::NONE)
            }
            #[doc = "Toggle State on Time-Out"]
            #[inline]
            pub fn toggle(self) -> &'a mut W {
                self.variant(TCACTW::TOGGLE)
            }
            #[doc = "Clear CCP on Time-Out"]
            #[inline]
            pub fn clrto(self) -> &'a mut W {
                self.variant(TCACTW::CLRTO)
            }
            #[doc = "Set CCP on Time-Out"]
            #[inline]
            pub fn setto(self) -> &'a mut W {
                self.variant(TCACTW::SETTO)
            }
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            #[inline]
            pub fn settogto(self) -> &'a mut W {
                self.variant(TCACTW::SETTOGTO)
            }
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            #[inline]
            pub fn clrtogto(self) -> &'a mut W {
                self.variant(TCACTW::CLRTOGTO)
            }
            #[doc = "Set CCP immediately and clear on Time-Out"]
            #[inline]
            pub fn setclrto(self) -> &'a mut W {
                self.variant(TCACTW::SETCLRTO)
            }
            #[doc = "Clear CCP immediately and set on Time-Out"]
            #[inline]
            pub fn clrsetto(self) -> &'a mut W {
                self.variant(TCACTW::CLRSETTO)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - GPTM Timer A Mode"]
            #[inline]
            pub fn tamr(&self) -> TAMRR {
                TAMRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode"]
            #[inline]
            pub fn tacmr(&self) -> TACMRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TACMRR { bits }
            }
            #[doc = "Bit 3 - GPTM Timer A Alternate Mode Select"]
            #[inline]
            pub fn taams(&self) -> TAAMSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAAMSR { bits }
            }
            #[doc = "Bit 4 - GPTM Timer A Count Direction"]
            #[inline]
            pub fn tacdir(&self) -> TACDIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TACDIRR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer A Match Interrupt Enable"]
            #[inline]
            pub fn tamie(&self) -> TAMIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMIER { bits }
            }
            #[doc = "Bit 6 - GPTM Timer A Wait-on-Trigger"]
            #[inline]
            pub fn tawot(&self) -> TAWOTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAWOTR { bits }
            }
            #[doc = "Bit 7 - GPTM Timer A Snap-Shot Mode"]
            #[inline]
            pub fn tasnaps(&self) -> TASNAPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TASNAPSR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer A Interval Load Write"]
            #[inline]
            pub fn taild(&self) -> TAILDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAILDR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer A PWM Interrupt Enable"]
            #[inline]
            pub fn tapwmie(&self) -> TAPWMIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAPWMIER { bits }
            }
            #[doc = "Bit 10 - GPTM Timer A Match Register Update"]
            #[inline]
            pub fn tamrsu(&self) -> TAMRSUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMRSUR { bits }
            }
            #[doc = "Bit 11 - GPTM Timer A PWM Legacy Operation"]
            #[inline]
            pub fn taplo(&self) -> TAPLOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAPLOR { bits }
            }
            #[doc = "Bit 12 - One-shot/Periodic Interrupt Disable"]
            #[inline]
            pub fn tacintd(&self) -> TACINTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TACINTDR { bits }
            }
            #[doc = "Bits 13:15 - Timer Compare Action Select"]
            #[inline]
            pub fn tcact(&self) -> TCACTR {
                TCACTR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - GPTM Timer A Mode"]
            #[inline]
            pub fn tamr(&mut self) -> _TAMRW {
                _TAMRW { w: self }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode"]
            #[inline]
            pub fn tacmr(&mut self) -> _TACMRW {
                _TACMRW { w: self }
            }
            #[doc = "Bit 3 - GPTM Timer A Alternate Mode Select"]
            #[inline]
            pub fn taams(&mut self) -> _TAAMSW {
                _TAAMSW { w: self }
            }
            #[doc = "Bit 4 - GPTM Timer A Count Direction"]
            #[inline]
            pub fn tacdir(&mut self) -> _TACDIRW {
                _TACDIRW { w: self }
            }
            #[doc = "Bit 5 - GPTM Timer A Match Interrupt Enable"]
            #[inline]
            pub fn tamie(&mut self) -> _TAMIEW {
                _TAMIEW { w: self }
            }
            #[doc = "Bit 6 - GPTM Timer A Wait-on-Trigger"]
            #[inline]
            pub fn tawot(&mut self) -> _TAWOTW {
                _TAWOTW { w: self }
            }
            #[doc = "Bit 7 - GPTM Timer A Snap-Shot Mode"]
            #[inline]
            pub fn tasnaps(&mut self) -> _TASNAPSW {
                _TASNAPSW { w: self }
            }
            #[doc = "Bit 8 - GPTM Timer A Interval Load Write"]
            #[inline]
            pub fn taild(&mut self) -> _TAILDW {
                _TAILDW { w: self }
            }
            #[doc = "Bit 9 - GPTM Timer A PWM Interrupt Enable"]
            #[inline]
            pub fn tapwmie(&mut self) -> _TAPWMIEW {
                _TAPWMIEW { w: self }
            }
            #[doc = "Bit 10 - GPTM Timer A Match Register Update"]
            #[inline]
            pub fn tamrsu(&mut self) -> _TAMRSUW {
                _TAMRSUW { w: self }
            }
            #[doc = "Bit 11 - GPTM Timer A PWM Legacy Operation"]
            #[inline]
            pub fn taplo(&mut self) -> _TAPLOW {
                _TAPLOW { w: self }
            }
            #[doc = "Bit 12 - One-shot/Periodic Interrupt Disable"]
            #[inline]
            pub fn tacintd(&mut self) -> _TACINTDW {
                _TACINTDW { w: self }
            }
            #[doc = "Bits 13:15 - Timer Compare Action Select"]
            #[inline]
            pub fn tcact(&mut self) -> _TCACTW {
                _TCACTW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer B Mode"]
    pub struct TBMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Mode"]
    pub mod tbmr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `TBMR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TBMRR {
            #[doc = "One-Shot Timer mode"]
            _1_SHOT,
            #[doc = "Periodic Timer mode"]
            PERIOD,
            #[doc = "Capture mode"]
            CAP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TBMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TBMRR::_1_SHOT => 0x01,
                    TBMRR::PERIOD => 0x02,
                    TBMRR::CAP => 0x03,
                    TBMRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TBMRR {
                match value {
                    1 => TBMRR::_1_SHOT,
                    2 => TBMRR::PERIOD,
                    3 => TBMRR::CAP,
                    i => TBMRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1_SHOT`"]
            #[inline]
            pub fn is_1_shot(&self) -> bool {
                *self == TBMRR::_1_SHOT
            }
            #[doc = "Checks if the value of the field is `PERIOD`"]
            #[inline]
            pub fn is_period(&self) -> bool {
                *self == TBMRR::PERIOD
            }
            #[doc = "Checks if the value of the field is `CAP`"]
            #[inline]
            pub fn is_cap(&self) -> bool {
                *self == TBMRR::CAP
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBCMRR {
            bits: bool,
        }
        impl TBCMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBAMSR {
            bits: bool,
        }
        impl TBAMSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBCDIRR {
            bits: bool,
        }
        impl TBCDIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMIER {
            bits: bool,
        }
        impl TBMIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBWOTR {
            bits: bool,
        }
        impl TBWOTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBSNAPSR {
            bits: bool,
        }
        impl TBSNAPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBILDR {
            bits: bool,
        }
        impl TBILDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBPWMIER {
            bits: bool,
        }
        impl TBPWMIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMRSUR {
            bits: bool,
        }
        impl TBMRSUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBPLOR {
            bits: bool,
        }
        impl TBPLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBCINTDR {
            bits: bool,
        }
        impl TBCINTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TCACT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TCACTR {
            #[doc = "Disable compare operations"]
            NONE,
            #[doc = "Toggle State on Time-Out"]
            TOGGLE,
            #[doc = "Clear CCP on Time-Out"]
            CLRTO,
            #[doc = "Set CCP on Time-Out"]
            SETTO,
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            SETTOGTO,
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            CLRTOGTO,
            #[doc = "Set CCP immediately and clear on Time-Out"]
            SETCLRTO,
            #[doc = "Clear CCP immediately and set on Time-Out"]
            CLRSETTO,
        }
        impl TCACTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TCACTR::NONE => 0,
                    TCACTR::TOGGLE => 0x01,
                    TCACTR::CLRTO => 0x02,
                    TCACTR::SETTO => 0x03,
                    TCACTR::SETTOGTO => 0x04,
                    TCACTR::CLRTOGTO => 0x05,
                    TCACTR::SETCLRTO => 0x06,
                    TCACTR::CLRSETTO => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TCACTR {
                match value {
                    0 => TCACTR::NONE,
                    1 => TCACTR::TOGGLE,
                    2 => TCACTR::CLRTO,
                    3 => TCACTR::SETTO,
                    4 => TCACTR::SETTOGTO,
                    5 => TCACTR::CLRTOGTO,
                    6 => TCACTR::SETCLRTO,
                    7 => TCACTR::CLRSETTO,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == TCACTR::NONE
            }
            #[doc = "Checks if the value of the field is `TOGGLE`"]
            #[inline]
            pub fn is_toggle(&self) -> bool {
                *self == TCACTR::TOGGLE
            }
            #[doc = "Checks if the value of the field is `CLRTO`"]
            #[inline]
            pub fn is_clrto(&self) -> bool {
                *self == TCACTR::CLRTO
            }
            #[doc = "Checks if the value of the field is `SETTO`"]
            #[inline]
            pub fn is_setto(&self) -> bool {
                *self == TCACTR::SETTO
            }
            #[doc = "Checks if the value of the field is `SETTOGTO`"]
            #[inline]
            pub fn is_settogto(&self) -> bool {
                *self == TCACTR::SETTOGTO
            }
            #[doc = "Checks if the value of the field is `CLRTOGTO`"]
            #[inline]
            pub fn is_clrtogto(&self) -> bool {
                *self == TCACTR::CLRTOGTO
            }
            #[doc = "Checks if the value of the field is `SETCLRTO`"]
            #[inline]
            pub fn is_setclrto(&self) -> bool {
                *self == TCACTR::SETCLRTO
            }
            #[doc = "Checks if the value of the field is `CLRSETTO`"]
            #[inline]
            pub fn is_clrsetto(&self) -> bool {
                *self == TCACTR::CLRSETTO
            }
        }
        #[doc = "Values that can be written to the field `TBMR`"]
        pub enum TBMRW {
            #[doc = "One-Shot Timer mode"]
            _1_SHOT,
            #[doc = "Periodic Timer mode"]
            PERIOD,
            #[doc = "Capture mode"]
            CAP,
        }
        impl TBMRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TBMRW::_1_SHOT => 1,
                    TBMRW::PERIOD => 2,
                    TBMRW::CAP => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TBMRW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "One-Shot Timer mode"]
            #[inline]
            pub fn _1_shot(self) -> &'a mut W {
                self.variant(TBMRW::_1_SHOT)
            }
            #[doc = "Periodic Timer mode"]
            #[inline]
            pub fn period(self) -> &'a mut W {
                self.variant(TBMRW::PERIOD)
            }
            #[doc = "Capture mode"]
            #[inline]
            pub fn cap(self) -> &'a mut W {
                self.variant(TBMRW::CAP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBCMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBCMRW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBAMSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBAMSW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBCDIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBCDIRW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMIEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBWOTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBWOTW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBSNAPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBSNAPSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBILDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBILDW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBPWMIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBPWMIEW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMRSUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMRSUW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBPLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBPLOW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBCINTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBCINTDW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TCACT`"]
        pub enum TCACTW {
            #[doc = "Disable compare operations"]
            NONE,
            #[doc = "Toggle State on Time-Out"]
            TOGGLE,
            #[doc = "Clear CCP on Time-Out"]
            CLRTO,
            #[doc = "Set CCP on Time-Out"]
            SETTO,
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            SETTOGTO,
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            CLRTOGTO,
            #[doc = "Set CCP immediately and clear on Time-Out"]
            SETCLRTO,
            #[doc = "Clear CCP immediately and set on Time-Out"]
            CLRSETTO,
        }
        impl TCACTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TCACTW::NONE => 0,
                    TCACTW::TOGGLE => 1,
                    TCACTW::CLRTO => 2,
                    TCACTW::SETTO => 3,
                    TCACTW::SETTOGTO => 4,
                    TCACTW::CLRTOGTO => 5,
                    TCACTW::SETCLRTO => 6,
                    TCACTW::CLRSETTO => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TCACTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TCACTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TCACTW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Disable compare operations"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(TCACTW::NONE)
            }
            #[doc = "Toggle State on Time-Out"]
            #[inline]
            pub fn toggle(self) -> &'a mut W {
                self.variant(TCACTW::TOGGLE)
            }
            #[doc = "Clear CCP on Time-Out"]
            #[inline]
            pub fn clrto(self) -> &'a mut W {
                self.variant(TCACTW::CLRTO)
            }
            #[doc = "Set CCP on Time-Out"]
            #[inline]
            pub fn setto(self) -> &'a mut W {
                self.variant(TCACTW::SETTO)
            }
            #[doc = "Set CCP immediately and toggle on Time-Out"]
            #[inline]
            pub fn settogto(self) -> &'a mut W {
                self.variant(TCACTW::SETTOGTO)
            }
            #[doc = "Clear CCP immediately and toggle on Time-Out"]
            #[inline]
            pub fn clrtogto(self) -> &'a mut W {
                self.variant(TCACTW::CLRTOGTO)
            }
            #[doc = "Set CCP immediately and clear on Time-Out"]
            #[inline]
            pub fn setclrto(self) -> &'a mut W {
                self.variant(TCACTW::SETCLRTO)
            }
            #[doc = "Clear CCP immediately and set on Time-Out"]
            #[inline]
            pub fn clrsetto(self) -> &'a mut W {
                self.variant(TCACTW::CLRSETTO)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - GPTM Timer B Mode"]
            #[inline]
            pub fn tbmr(&self) -> TBMRR {
                TBMRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - GPTM Timer B Capture Mode"]
            #[inline]
            pub fn tbcmr(&self) -> TBCMRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBCMRR { bits }
            }
            #[doc = "Bit 3 - GPTM Timer B Alternate Mode Select"]
            #[inline]
            pub fn tbams(&self) -> TBAMSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBAMSR { bits }
            }
            #[doc = "Bit 4 - GPTM Timer B Count Direction"]
            #[inline]
            pub fn tbcdir(&self) -> TBCDIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBCDIRR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer B Match Interrupt Enable"]
            #[inline]
            pub fn tbmie(&self) -> TBMIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMIER { bits }
            }
            #[doc = "Bit 6 - GPTM Timer B Wait-on-Trigger"]
            #[inline]
            pub fn tbwot(&self) -> TBWOTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBWOTR { bits }
            }
            #[doc = "Bit 7 - GPTM Timer B Snap-Shot Mode"]
            #[inline]
            pub fn tbsnaps(&self) -> TBSNAPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBSNAPSR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer B Interval Load Write"]
            #[inline]
            pub fn tbild(&self) -> TBILDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBILDR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer B PWM Interrupt Enable"]
            #[inline]
            pub fn tbpwmie(&self) -> TBPWMIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBPWMIER { bits }
            }
            #[doc = "Bit 10 - GPTM Timer B Match Register Update"]
            #[inline]
            pub fn tbmrsu(&self) -> TBMRSUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMRSUR { bits }
            }
            #[doc = "Bit 11 - GPTM Timer B PWM Legacy Operation"]
            #[inline]
            pub fn tbplo(&self) -> TBPLOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBPLOR { bits }
            }
            #[doc = "Bit 12 - One-Shot/Periodic Interrupt Disable"]
            #[inline]
            pub fn tbcintd(&self) -> TBCINTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBCINTDR { bits }
            }
            #[doc = "Bits 13:15 - Timer Compare Action Select"]
            #[inline]
            pub fn tcact(&self) -> TCACTR {
                TCACTR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - GPTM Timer B Mode"]
            #[inline]
            pub fn tbmr(&mut self) -> _TBMRW {
                _TBMRW { w: self }
            }
            #[doc = "Bit 2 - GPTM Timer B Capture Mode"]
            #[inline]
            pub fn tbcmr(&mut self) -> _TBCMRW {
                _TBCMRW { w: self }
            }
            #[doc = "Bit 3 - GPTM Timer B Alternate Mode Select"]
            #[inline]
            pub fn tbams(&mut self) -> _TBAMSW {
                _TBAMSW { w: self }
            }
            #[doc = "Bit 4 - GPTM Timer B Count Direction"]
            #[inline]
            pub fn tbcdir(&mut self) -> _TBCDIRW {
                _TBCDIRW { w: self }
            }
            #[doc = "Bit 5 - GPTM Timer B Match Interrupt Enable"]
            #[inline]
            pub fn tbmie(&mut self) -> _TBMIEW {
                _TBMIEW { w: self }
            }
            #[doc = "Bit 6 - GPTM Timer B Wait-on-Trigger"]
            #[inline]
            pub fn tbwot(&mut self) -> _TBWOTW {
                _TBWOTW { w: self }
            }
            #[doc = "Bit 7 - GPTM Timer B Snap-Shot Mode"]
            #[inline]
            pub fn tbsnaps(&mut self) -> _TBSNAPSW {
                _TBSNAPSW { w: self }
            }
            #[doc = "Bit 8 - GPTM Timer B Interval Load Write"]
            #[inline]
            pub fn tbild(&mut self) -> _TBILDW {
                _TBILDW { w: self }
            }
            #[doc = "Bit 9 - GPTM Timer B PWM Interrupt Enable"]
            #[inline]
            pub fn tbpwmie(&mut self) -> _TBPWMIEW {
                _TBPWMIEW { w: self }
            }
            #[doc = "Bit 10 - GPTM Timer B Match Register Update"]
            #[inline]
            pub fn tbmrsu(&mut self) -> _TBMRSUW {
                _TBMRSUW { w: self }
            }
            #[doc = "Bit 11 - GPTM Timer B PWM Legacy Operation"]
            #[inline]
            pub fn tbplo(&mut self) -> _TBPLOW {
                _TBPLOW { w: self }
            }
            #[doc = "Bit 12 - One-Shot/Periodic Interrupt Disable"]
            #[inline]
            pub fn tbcintd(&mut self) -> _TBCINTDW {
                _TBCINTDW { w: self }
            }
            #[doc = "Bits 13:15 - Timer Compare Action Select"]
            #[inline]
            pub fn tcact(&mut self) -> _TCACTW {
                _TCACTW { w: self }
            }
        }
    }
    #[doc = "GPTM Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAENR {
            bits: bool,
        }
        impl TAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TASTALLR {
            bits: bool,
        }
        impl TASTALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TAEVENT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TAEVENTR {
            #[doc = "Positive edge"]
            POS,
            #[doc = "Negative edge"]
            NEG,
            #[doc = "Both edges"]
            BOTH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TAEVENTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TAEVENTR::POS => 0,
                    TAEVENTR::NEG => 0x01,
                    TAEVENTR::BOTH => 0x03,
                    TAEVENTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TAEVENTR {
                match value {
                    0 => TAEVENTR::POS,
                    1 => TAEVENTR::NEG,
                    3 => TAEVENTR::BOTH,
                    i => TAEVENTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `POS`"]
            #[inline]
            pub fn is_pos(&self) -> bool {
                *self == TAEVENTR::POS
            }
            #[doc = "Checks if the value of the field is `NEG`"]
            #[inline]
            pub fn is_neg(&self) -> bool {
                *self == TAEVENTR::NEG
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == TAEVENTR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCENR {
            bits: bool,
        }
        impl RTCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAOTER {
            bits: bool,
        }
        impl TAOTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAPWMLR {
            bits: bool,
        }
        impl TAPWMLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBENR {
            bits: bool,
        }
        impl TBENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBSTALLR {
            bits: bool,
        }
        impl TBSTALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TBEVENT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TBEVENTR {
            #[doc = "Positive edge"]
            POS,
            #[doc = "Negative edge"]
            NEG,
            #[doc = "Both edges"]
            BOTH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TBEVENTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TBEVENTR::POS => 0,
                    TBEVENTR::NEG => 0x01,
                    TBEVENTR::BOTH => 0x03,
                    TBEVENTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TBEVENTR {
                match value {
                    0 => TBEVENTR::POS,
                    1 => TBEVENTR::NEG,
                    3 => TBEVENTR::BOTH,
                    i => TBEVENTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `POS`"]
            #[inline]
            pub fn is_pos(&self) -> bool {
                *self == TBEVENTR::POS
            }
            #[doc = "Checks if the value of the field is `NEG`"]
            #[inline]
            pub fn is_neg(&self) -> bool {
                *self == TBEVENTR::NEG
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == TBEVENTR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBOTER {
            bits: bool,
        }
        impl TBOTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBPWMLR {
            bits: bool,
        }
        impl TBPWMLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TASTALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TASTALLW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TAEVENT`"]
        pub enum TAEVENTW {
            #[doc = "Positive edge"]
            POS,
            #[doc = "Negative edge"]
            NEG,
            #[doc = "Both edges"]
            BOTH,
        }
        impl TAEVENTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TAEVENTW::POS => 0,
                    TAEVENTW::NEG => 1,
                    TAEVENTW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAEVENTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAEVENTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TAEVENTW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Positive edge"]
            #[inline]
            pub fn pos(self) -> &'a mut W {
                self.variant(TAEVENTW::POS)
            }
            #[doc = "Negative edge"]
            #[inline]
            pub fn neg(self) -> &'a mut W {
                self.variant(TAEVENTW::NEG)
            }
            #[doc = "Both edges"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(TAEVENTW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAOTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAOTEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAPWMLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAPWMLW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBENW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBSTALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBSTALLW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TBEVENT`"]
        pub enum TBEVENTW {
            #[doc = "Positive edge"]
            POS,
            #[doc = "Negative edge"]
            NEG,
            #[doc = "Both edges"]
            BOTH,
        }
        impl TBEVENTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TBEVENTW::POS => 0,
                    TBEVENTW::NEG => 1,
                    TBEVENTW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBEVENTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBEVENTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TBEVENTW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Positive edge"]
            #[inline]
            pub fn pos(self) -> &'a mut W {
                self.variant(TBEVENTW::POS)
            }
            #[doc = "Negative edge"]
            #[inline]
            pub fn neg(self) -> &'a mut W {
                self.variant(TBEVENTW::NEG)
            }
            #[doc = "Both edges"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(TBEVENTW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBOTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBOTEW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBPWMLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBPWMLW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM Timer A Enable"]
            #[inline]
            pub fn taen(&self) -> TAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAENR { bits }
            }
            #[doc = "Bit 1 - GPTM Timer A Stall Enable"]
            #[inline]
            pub fn tastall(&self) -> TASTALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TASTALLR { bits }
            }
            #[doc = "Bits 2:3 - GPTM Timer A Event Mode"]
            #[inline]
            pub fn taevent(&self) -> TAEVENTR {
                TAEVENTR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - GPTM RTC Stall Enable"]
            #[inline]
            pub fn rtcen(&self) -> RTCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCENR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer A Output Trigger Enable"]
            #[inline]
            pub fn taote(&self) -> TAOTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAOTER { bits }
            }
            #[doc = "Bit 6 - GPTM Timer A PWM Output Level"]
            #[inline]
            pub fn tapwml(&self) -> TAPWMLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAPWMLR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer B Enable"]
            #[inline]
            pub fn tben(&self) -> TBENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBENR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer B Stall Enable"]
            #[inline]
            pub fn tbstall(&self) -> TBSTALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBSTALLR { bits }
            }
            #[doc = "Bits 10:11 - GPTM Timer B Event Mode"]
            #[inline]
            pub fn tbevent(&self) -> TBEVENTR {
                TBEVENTR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 13 - GPTM Timer B Output Trigger Enable"]
            #[inline]
            pub fn tbote(&self) -> TBOTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBOTER { bits }
            }
            #[doc = "Bit 14 - GPTM Timer B PWM Output Level"]
            #[inline]
            pub fn tbpwml(&self) -> TBPWMLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBPWMLR { bits }
            }
        }
        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 = "Bit 0 - GPTM Timer A Enable"]
            #[inline]
            pub fn taen(&mut self) -> _TAENW {
                _TAENW { w: self }
            }
            #[doc = "Bit 1 - GPTM Timer A Stall Enable"]
            #[inline]
            pub fn tastall(&mut self) -> _TASTALLW {
                _TASTALLW { w: self }
            }
            #[doc = "Bits 2:3 - GPTM Timer A Event Mode"]
            #[inline]
            pub fn taevent(&mut self) -> _TAEVENTW {
                _TAEVENTW { w: self }
            }
            #[doc = "Bit 4 - GPTM RTC Stall Enable"]
            #[inline]
            pub fn rtcen(&mut self) -> _RTCENW {
                _RTCENW { w: self }
            }
            #[doc = "Bit 5 - GPTM Timer A Output Trigger Enable"]
            #[inline]
            pub fn taote(&mut self) -> _TAOTEW {
                _TAOTEW { w: self }
            }
            #[doc = "Bit 6 - GPTM Timer A PWM Output Level"]
            #[inline]
            pub fn tapwml(&mut self) -> _TAPWMLW {
                _TAPWMLW { w: self }
            }
            #[doc = "Bit 8 - GPTM Timer B Enable"]
            #[inline]
            pub fn tben(&mut self) -> _TBENW {
                _TBENW { w: self }
            }
            #[doc = "Bit 9 - GPTM Timer B Stall Enable"]
            #[inline]
            pub fn tbstall(&mut self) -> _TBSTALLW {
                _TBSTALLW { w: self }
            }
            #[doc = "Bits 10:11 - GPTM Timer B Event Mode"]
            #[inline]
            pub fn tbevent(&mut self) -> _TBEVENTW {
                _TBEVENTW { w: self }
            }
            #[doc = "Bit 13 - GPTM Timer B Output Trigger Enable"]
            #[inline]
            pub fn tbote(&mut self) -> _TBOTEW {
                _TBOTEW { w: self }
            }
            #[doc = "Bit 14 - GPTM Timer B PWM Output Level"]
            #[inline]
            pub fn tbpwml(&mut self) -> _TBPWMLW {
                _TBPWMLW { w: self }
            }
        }
    }
    #[doc = "GPTM Synchronize"]
    pub struct SYNC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Synchronize"]
    pub mod sync {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SYNC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SYNCT0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT0R {
            #[doc = "GPTM0 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM0 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM0 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM0 is triggered"]
            TATB,
        }
        impl SYNCT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT0R::NONE => 0,
                    SYNCT0R::TA => 0x01,
                    SYNCT0R::TB => 0x02,
                    SYNCT0R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT0R {
                match value {
                    0 => SYNCT0R::NONE,
                    1 => SYNCT0R::TA,
                    2 => SYNCT0R::TB,
                    3 => SYNCT0R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT0R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT0R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT0R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT0R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT1R {
            #[doc = "GPTM1 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM1 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM1 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM1 is triggered"]
            TATB,
        }
        impl SYNCT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT1R::NONE => 0,
                    SYNCT1R::TA => 0x01,
                    SYNCT1R::TB => 0x02,
                    SYNCT1R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT1R {
                match value {
                    0 => SYNCT1R::NONE,
                    1 => SYNCT1R::TA,
                    2 => SYNCT1R::TB,
                    3 => SYNCT1R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT1R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT1R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT1R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT1R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT2`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT2R {
            #[doc = "GPTM2 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM2 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM2 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM2 is triggered"]
            TATB,
        }
        impl SYNCT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT2R::NONE => 0,
                    SYNCT2R::TA => 0x01,
                    SYNCT2R::TB => 0x02,
                    SYNCT2R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT2R {
                match value {
                    0 => SYNCT2R::NONE,
                    1 => SYNCT2R::TA,
                    2 => SYNCT2R::TB,
                    3 => SYNCT2R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT2R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT2R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT2R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT2R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT3`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT3R {
            #[doc = "GPTM3 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM3 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM3 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM3 is triggered"]
            TATB,
        }
        impl SYNCT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT3R::NONE => 0,
                    SYNCT3R::TA => 0x01,
                    SYNCT3R::TB => 0x02,
                    SYNCT3R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT3R {
                match value {
                    0 => SYNCT3R::NONE,
                    1 => SYNCT3R::TA,
                    2 => SYNCT3R::TB,
                    3 => SYNCT3R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT3R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT3R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT3R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT3R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT4`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT4R {
            #[doc = "GPTM4 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM4 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM4 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM4 is triggered"]
            TATB,
        }
        impl SYNCT4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT4R::NONE => 0,
                    SYNCT4R::TA => 0x01,
                    SYNCT4R::TB => 0x02,
                    SYNCT4R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT4R {
                match value {
                    0 => SYNCT4R::NONE,
                    1 => SYNCT4R::TA,
                    2 => SYNCT4R::TB,
                    3 => SYNCT4R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT4R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT4R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT4R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT4R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT5`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT5R {
            #[doc = "GPTM5 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM5 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM5 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM5 is triggered"]
            TATB,
        }
        impl SYNCT5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT5R::NONE => 0,
                    SYNCT5R::TA => 0x01,
                    SYNCT5R::TB => 0x02,
                    SYNCT5R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT5R {
                match value {
                    0 => SYNCT5R::NONE,
                    1 => SYNCT5R::TA,
                    2 => SYNCT5R::TB,
                    3 => SYNCT5R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT5R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT5R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT5R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT5R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT6`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT6R {
            #[doc = "GPTM6 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM6 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM6 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM6 is triggered"]
            TATB,
        }
        impl SYNCT6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT6R::NONE => 0,
                    SYNCT6R::TA => 0x01,
                    SYNCT6R::TB => 0x02,
                    SYNCT6R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT6R {
                match value {
                    0 => SYNCT6R::NONE,
                    1 => SYNCT6R::TA,
                    2 => SYNCT6R::TB,
                    3 => SYNCT6R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT6R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT6R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT6R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT6R::TATB
            }
        }
        #[doc = "Possible values of the field `SYNCT7`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SYNCT7R {
            #[doc = "GPT7 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM7 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM7 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM7 is triggered"]
            TATB,
        }
        impl SYNCT7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SYNCT7R::NONE => 0,
                    SYNCT7R::TA => 0x01,
                    SYNCT7R::TB => 0x02,
                    SYNCT7R::TATB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SYNCT7R {
                match value {
                    0 => SYNCT7R::NONE,
                    1 => SYNCT7R::TA,
                    2 => SYNCT7R::TB,
                    3 => SYNCT7R::TATB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == SYNCT7R::NONE
            }
            #[doc = "Checks if the value of the field is `TA`"]
            #[inline]
            pub fn is_ta(&self) -> bool {
                *self == SYNCT7R::TA
            }
            #[doc = "Checks if the value of the field is `TB`"]
            #[inline]
            pub fn is_tb(&self) -> bool {
                *self == SYNCT7R::TB
            }
            #[doc = "Checks if the value of the field is `TATB`"]
            #[inline]
            pub fn is_tatb(&self) -> bool {
                *self == SYNCT7R::TATB
            }
        }
        #[doc = "Values that can be written to the field `SYNCT0`"]
        pub enum SYNCT0W {
            #[doc = "GPTM0 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM0 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM0 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM0 is triggered"]
            TATB,
        }
        impl SYNCT0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT0W::NONE => 0,
                    SYNCT0W::TA => 1,
                    SYNCT0W::TB => 2,
                    SYNCT0W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT0W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM0 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT0W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM0 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT0W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM0 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT0W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM0 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT0W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT1`"]
        pub enum SYNCT1W {
            #[doc = "GPTM1 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM1 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM1 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM1 is triggered"]
            TATB,
        }
        impl SYNCT1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT1W::NONE => 0,
                    SYNCT1W::TA => 1,
                    SYNCT1W::TB => 2,
                    SYNCT1W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT1W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM1 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT1W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM1 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT1W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM1 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT1W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM1 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT1W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT2`"]
        pub enum SYNCT2W {
            #[doc = "GPTM2 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM2 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM2 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM2 is triggered"]
            TATB,
        }
        impl SYNCT2W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT2W::NONE => 0,
                    SYNCT2W::TA => 1,
                    SYNCT2W::TB => 2,
                    SYNCT2W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT2W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT2W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM2 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT2W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM2 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT2W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM2 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT2W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM2 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT2W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT3`"]
        pub enum SYNCT3W {
            #[doc = "GPTM3 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM3 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM3 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM3 is triggered"]
            TATB,
        }
        impl SYNCT3W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT3W::NONE => 0,
                    SYNCT3W::TA => 1,
                    SYNCT3W::TB => 2,
                    SYNCT3W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT3W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT3W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM3 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT3W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM3 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT3W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM3 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT3W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM3 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT3W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT4`"]
        pub enum SYNCT4W {
            #[doc = "GPTM4 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM4 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM4 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM4 is triggered"]
            TATB,
        }
        impl SYNCT4W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT4W::NONE => 0,
                    SYNCT4W::TA => 1,
                    SYNCT4W::TB => 2,
                    SYNCT4W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT4W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT4W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM4 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT4W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM4 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT4W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM4 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT4W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM4 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT4W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT5`"]
        pub enum SYNCT5W {
            #[doc = "GPTM5 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM5 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM5 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM5 is triggered"]
            TATB,
        }
        impl SYNCT5W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT5W::NONE => 0,
                    SYNCT5W::TA => 1,
                    SYNCT5W::TB => 2,
                    SYNCT5W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT5W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT5W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM5 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT5W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM5 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT5W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM5 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT5W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM5 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT5W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT6`"]
        pub enum SYNCT6W {
            #[doc = "GPTM6 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM6 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM6 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM6 is triggered"]
            TATB,
        }
        impl SYNCT6W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT6W::NONE => 0,
                    SYNCT6W::TA => 1,
                    SYNCT6W::TB => 2,
                    SYNCT6W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT6W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT6W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPTM6 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT6W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM6 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT6W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM6 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT6W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM6 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT6W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SYNCT7`"]
        pub enum SYNCT7W {
            #[doc = "GPT7 is not affected"]
            NONE,
            #[doc = "A timeout event for Timer A of GPTM7 is triggered"]
            TA,
            #[doc = "A timeout event for Timer B of GPTM7 is triggered"]
            TB,
            #[doc = "A timeout event for both Timer A and Timer B of GPTM7 is triggered"]
            TATB,
        }
        impl SYNCT7W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SYNCT7W::NONE => 0,
                    SYNCT7W::TA => 1,
                    SYNCT7W::TB => 2,
                    SYNCT7W::TATB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCT7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCT7W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SYNCT7W) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "GPT7 is not affected"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(SYNCT7W::NONE)
            }
            #[doc = "A timeout event for Timer A of GPTM7 is triggered"]
            #[inline]
            pub fn ta(self) -> &'a mut W {
                self.variant(SYNCT7W::TA)
            }
            #[doc = "A timeout event for Timer B of GPTM7 is triggered"]
            #[inline]
            pub fn tb(self) -> &'a mut W {
                self.variant(SYNCT7W::TB)
            }
            #[doc = "A timeout event for both Timer A and Timer B of GPTM7 is triggered"]
            #[inline]
            pub fn tatb(self) -> &'a mut W {
                self.variant(SYNCT7W::TATB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Synchronize GPTM Timer 0"]
            #[inline]
            pub fn synct0(&self) -> SYNCT0R {
                SYNCT0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Synchronize GPTM Timer 1"]
            #[inline]
            pub fn synct1(&self) -> SYNCT1R {
                SYNCT1R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Synchronize GPTM Timer 2"]
            #[inline]
            pub fn synct2(&self) -> SYNCT2R {
                SYNCT2R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Synchronize GPTM Timer 3"]
            #[inline]
            pub fn synct3(&self) -> SYNCT3R {
                SYNCT3R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - Synchronize GPTM Timer 4"]
            #[inline]
            pub fn synct4(&self) -> SYNCT4R {
                SYNCT4R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Synchronize GPTM Timer 5"]
            #[inline]
            pub fn synct5(&self) -> SYNCT5R {
                SYNCT5R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - Synchronize GPTM Timer 6"]
            #[inline]
            pub fn synct6(&self) -> SYNCT6R {
                SYNCT6R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - Synchronize GPTM Timer 7"]
            #[inline]
            pub fn synct7(&self) -> SYNCT7R {
                SYNCT7R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Synchronize GPTM Timer 0"]
            #[inline]
            pub fn synct0(&mut self) -> _SYNCT0W {
                _SYNCT0W { w: self }
            }
            #[doc = "Bits 2:3 - Synchronize GPTM Timer 1"]
            #[inline]
            pub fn synct1(&mut self) -> _SYNCT1W {
                _SYNCT1W { w: self }
            }
            #[doc = "Bits 4:5 - Synchronize GPTM Timer 2"]
            #[inline]
            pub fn synct2(&mut self) -> _SYNCT2W {
                _SYNCT2W { w: self }
            }
            #[doc = "Bits 6:7 - Synchronize GPTM Timer 3"]
            #[inline]
            pub fn synct3(&mut self) -> _SYNCT3W {
                _SYNCT3W { w: self }
            }
            #[doc = "Bits 8:9 - Synchronize GPTM Timer 4"]
            #[inline]
            pub fn synct4(&mut self) -> _SYNCT4W {
                _SYNCT4W { w: self }
            }
            #[doc = "Bits 10:11 - Synchronize GPTM Timer 5"]
            #[inline]
            pub fn synct5(&mut self) -> _SYNCT5W {
                _SYNCT5W { w: self }
            }
            #[doc = "Bits 12:13 - Synchronize GPTM Timer 6"]
            #[inline]
            pub fn synct6(&mut self) -> _SYNCT6W {
                _SYNCT6W { w: self }
            }
            #[doc = "Bits 14:15 - Synchronize GPTM Timer 7"]
            #[inline]
            pub fn synct7(&mut self) -> _SYNCT7W {
                _SYNCT7W { w: self }
            }
        }
    }
    #[doc = "GPTM Interrupt Mask"]
    pub struct IMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Interrupt Mask"]
    pub mod imr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TATOIMR {
            bits: bool,
        }
        impl TATOIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAMIMR {
            bits: bool,
        }
        impl CAMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAEIMR {
            bits: bool,
        }
        impl CAEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCIMR {
            bits: bool,
        }
        impl RTCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMIMR {
            bits: bool,
        }
        impl TAMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAAIMR {
            bits: bool,
        }
        impl DMAAIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBTOIMR {
            bits: bool,
        }
        impl TBTOIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBMIMR {
            bits: bool,
        }
        impl CBMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBEIMR {
            bits: bool,
        }
        impl CBEIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMIMR {
            bits: bool,
        }
        impl TBMIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMABIMR {
            bits: bool,
        }
        impl DMABIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TATOIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TATOIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAMIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAEIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAAIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAAIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBTOIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBTOIMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBMIMW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBEIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBEIMW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMIMW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMABIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMABIMW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM Timer A Time-Out Interrupt Mask"]
            #[inline]
            pub fn tatoim(&self) -> TATOIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TATOIMR { bits }
            }
            #[doc = "Bit 1 - GPTM Timer A Capture Mode Match Interrupt Mask"]
            #[inline]
            pub fn camim(&self) -> CAMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAMIMR { bits }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode Event Interrupt Mask"]
            #[inline]
            pub fn caeim(&self) -> CAEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAEIMR { bits }
            }
            #[doc = "Bit 3 - GPTM RTC Interrupt Mask"]
            #[inline]
            pub fn rtcim(&self) -> RTCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCIMR { bits }
            }
            #[doc = "Bit 4 - GPTM Timer A Match Interrupt Mask"]
            #[inline]
            pub fn tamim(&self) -> TAMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMIMR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer A DMA Done Interrupt Mask"]
            #[inline]
            pub fn dmaaim(&self) -> DMAAIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAAIMR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer B Time-Out Interrupt Mask"]
            #[inline]
            pub fn tbtoim(&self) -> TBTOIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBTOIMR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer B Capture Mode Match Interrupt Mask"]
            #[inline]
            pub fn cbmim(&self) -> CBMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBMIMR { bits }
            }
            #[doc = "Bit 10 - GPTM Timer B Capture Mode Event Interrupt Mask"]
            #[inline]
            pub fn cbeim(&self) -> CBEIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBEIMR { bits }
            }
            #[doc = "Bit 11 - GPTM Timer B Match Interrupt Mask"]
            #[inline]
            pub fn tbmim(&self) -> TBMIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMIMR { bits }
            }
            #[doc = "Bit 13 - GPTM Timer B DMA Done Interrupt Mask"]
            #[inline]
            pub fn dmabim(&self) -> DMABIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMABIMR { bits }
            }
        }
        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 = "Bit 0 - GPTM Timer A Time-Out Interrupt Mask"]
            #[inline]
            pub fn tatoim(&mut self) -> _TATOIMW {
                _TATOIMW { w: self }
            }
            #[doc = "Bit 1 - GPTM Timer A Capture Mode Match Interrupt Mask"]
            #[inline]
            pub fn camim(&mut self) -> _CAMIMW {
                _CAMIMW { w: self }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode Event Interrupt Mask"]
            #[inline]
            pub fn caeim(&mut self) -> _CAEIMW {
                _CAEIMW { w: self }
            }
            #[doc = "Bit 3 - GPTM RTC Interrupt Mask"]
            #[inline]
            pub fn rtcim(&mut self) -> _RTCIMW {
                _RTCIMW { w: self }
            }
            #[doc = "Bit 4 - GPTM Timer A Match Interrupt Mask"]
            #[inline]
            pub fn tamim(&mut self) -> _TAMIMW {
                _TAMIMW { w: self }
            }
            #[doc = "Bit 5 - GPTM Timer A DMA Done Interrupt Mask"]
            #[inline]
            pub fn dmaaim(&mut self) -> _DMAAIMW {
                _DMAAIMW { w: self }
            }
            #[doc = "Bit 8 - GPTM Timer B Time-Out Interrupt Mask"]
            #[inline]
            pub fn tbtoim(&mut self) -> _TBTOIMW {
                _TBTOIMW { w: self }
            }
            #[doc = "Bit 9 - GPTM Timer B Capture Mode Match Interrupt Mask"]
            #[inline]
            pub fn cbmim(&mut self) -> _CBMIMW {
                _CBMIMW { w: self }
            }
            #[doc = "Bit 10 - GPTM Timer B Capture Mode Event Interrupt Mask"]
            #[inline]
            pub fn cbeim(&mut self) -> _CBEIMW {
                _CBEIMW { w: self }
            }
            #[doc = "Bit 11 - GPTM Timer B Match Interrupt Mask"]
            #[inline]
            pub fn tbmim(&mut self) -> _TBMIMW {
                _TBMIMW { w: self }
            }
            #[doc = "Bit 13 - GPTM Timer B DMA Done Interrupt Mask"]
            #[inline]
            pub fn dmabim(&mut self) -> _DMABIMW {
                _DMABIMW { w: self }
            }
        }
    }
    #[doc = "GPTM Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TATORISR {
            bits: bool,
        }
        impl TATORISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAMRISR {
            bits: bool,
        }
        impl CAMRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAERISR {
            bits: bool,
        }
        impl CAERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCRISR {
            bits: bool,
        }
        impl RTCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMRISR {
            bits: bool,
        }
        impl TAMRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAARISR {
            bits: bool,
        }
        impl DMAARISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBTORISR {
            bits: bool,
        }
        impl TBTORISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBMRISR {
            bits: bool,
        }
        impl CBMRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBERISR {
            bits: bool,
        }
        impl CBERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMRISR {
            bits: bool,
        }
        impl TBMRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMABRISR {
            bits: bool,
        }
        impl DMABRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM Timer A Time-Out Raw Interrupt"]
            #[inline]
            pub fn tatoris(&self) -> TATORISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TATORISR { bits }
            }
            #[doc = "Bit 1 - GPTM Timer A Capture Mode Match Raw Interrupt"]
            #[inline]
            pub fn camris(&self) -> CAMRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAMRISR { bits }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode Event Raw Interrupt"]
            #[inline]
            pub fn caeris(&self) -> CAERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAERISR { bits }
            }
            #[doc = "Bit 3 - GPTM RTC Raw Interrupt"]
            #[inline]
            pub fn rtcris(&self) -> RTCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCRISR { bits }
            }
            #[doc = "Bit 4 - GPTM Timer A Match Raw Interrupt"]
            #[inline]
            pub fn tamris(&self) -> TAMRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMRISR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer A DMA Done Raw Interrupt Status"]
            #[inline]
            pub fn dmaaris(&self) -> DMAARISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAARISR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer B Time-Out Raw Interrupt"]
            #[inline]
            pub fn tbtoris(&self) -> TBTORISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBTORISR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer B Capture Mode Match Raw Interrupt"]
            #[inline]
            pub fn cbmris(&self) -> CBMRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBMRISR { bits }
            }
            #[doc = "Bit 10 - GPTM Timer B Capture Mode Event Raw Interrupt"]
            #[inline]
            pub fn cberis(&self) -> CBERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBERISR { bits }
            }
            #[doc = "Bit 11 - GPTM Timer B Match Raw Interrupt"]
            #[inline]
            pub fn tbmris(&self) -> TBMRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMRISR { bits }
            }
            #[doc = "Bit 13 - GPTM Timer B DMA Done Raw Interrupt Status"]
            #[inline]
            pub fn dmabris(&self) -> DMABRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMABRISR { bits }
            }
        }
    }
    #[doc = "GPTM Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TATOMISR {
            bits: bool,
        }
        impl TATOMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAMMISR {
            bits: bool,
        }
        impl CAMMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAEMISR {
            bits: bool,
        }
        impl CAEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCMISR {
            bits: bool,
        }
        impl RTCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMMISR {
            bits: bool,
        }
        impl TAMMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAAMISR {
            bits: bool,
        }
        impl DMAAMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBTOMISR {
            bits: bool,
        }
        impl TBTOMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBMMISR {
            bits: bool,
        }
        impl CBMMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBEMISR {
            bits: bool,
        }
        impl CBEMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMMISR {
            bits: bool,
        }
        impl TBMMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMABMISR {
            bits: bool,
        }
        impl DMABMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM Timer A Time-Out Masked Interrupt"]
            #[inline]
            pub fn tatomis(&self) -> TATOMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TATOMISR { bits }
            }
            #[doc = "Bit 1 - GPTM Timer A Capture Mode Match Masked Interrupt"]
            #[inline]
            pub fn cammis(&self) -> CAMMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAMMISR { bits }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode Event Masked Interrupt"]
            #[inline]
            pub fn caemis(&self) -> CAEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAEMISR { bits }
            }
            #[doc = "Bit 3 - GPTM RTC Masked Interrupt"]
            #[inline]
            pub fn rtcmis(&self) -> RTCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCMISR { bits }
            }
            #[doc = "Bit 4 - GPTM Timer A Match Masked Interrupt"]
            #[inline]
            pub fn tammis(&self) -> TAMMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMMISR { bits }
            }
            #[doc = "Bit 5 - GPTM Timer A DMA Done Masked Interrupt"]
            #[inline]
            pub fn dmaamis(&self) -> DMAAMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAAMISR { bits }
            }
            #[doc = "Bit 8 - GPTM Timer B Time-Out Masked Interrupt"]
            #[inline]
            pub fn tbtomis(&self) -> TBTOMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBTOMISR { bits }
            }
            #[doc = "Bit 9 - GPTM Timer B Capture Mode Match Masked Interrupt"]
            #[inline]
            pub fn cbmmis(&self) -> CBMMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBMMISR { bits }
            }
            #[doc = "Bit 10 - GPTM Timer B Capture Mode Event Masked Interrupt"]
            #[inline]
            pub fn cbemis(&self) -> CBEMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBEMISR { bits }
            }
            #[doc = "Bit 11 - GPTM Timer B Match Masked Interrupt"]
            #[inline]
            pub fn tbmmis(&self) -> TBMMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMMISR { bits }
            }
            #[doc = "Bit 13 - GPTM Timer B DMA Done Masked Interrupt"]
            #[inline]
            pub fn dmabmis(&self) -> DMABMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMABMISR { bits }
            }
        }
    }
    #[doc = "GPTM Interrupt Clear"]
    pub struct ICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Interrupt Clear"]
    pub mod icr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ICR {
            #[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 _TATOCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TATOCINTW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAMCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAMCINTW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAECINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAECINTW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCCINTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMCINTW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAAINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAAINTW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBTOCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBTOCINTW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBMCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBMCINTW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBECINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBECINTW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMCINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMCINTW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMABINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMABINTW<'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 = 13;
                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 = "Bit 0 - GPTM Timer A Time-Out Raw Interrupt"]
            #[inline]
            pub fn tatocint(&mut self) -> _TATOCINTW {
                _TATOCINTW { w: self }
            }
            #[doc = "Bit 1 - GPTM Timer A Capture Mode Match Interrupt Clear"]
            #[inline]
            pub fn camcint(&mut self) -> _CAMCINTW {
                _CAMCINTW { w: self }
            }
            #[doc = "Bit 2 - GPTM Timer A Capture Mode Event Interrupt Clear"]
            #[inline]
            pub fn caecint(&mut self) -> _CAECINTW {
                _CAECINTW { w: self }
            }
            #[doc = "Bit 3 - GPTM RTC Interrupt Clear"]
            #[inline]
            pub fn rtccint(&mut self) -> _RTCCINTW {
                _RTCCINTW { w: self }
            }
            #[doc = "Bit 4 - GPTM Timer A Match Interrupt Clear"]
            #[inline]
            pub fn tamcint(&mut self) -> _TAMCINTW {
                _TAMCINTW { w: self }
            }
            #[doc = "Bit 5 - GPTM Timer A DMA Done Interrupt Clear"]
            #[inline]
            pub fn dmaaint(&mut self) -> _DMAAINTW {
                _DMAAINTW { w: self }
            }
            #[doc = "Bit 8 - GPTM Timer B Time-Out Interrupt Clear"]
            #[inline]
            pub fn tbtocint(&mut self) -> _TBTOCINTW {
                _TBTOCINTW { w: self }
            }
            #[doc = "Bit 9 - GPTM Timer B Capture Mode Match Interrupt Clear"]
            #[inline]
            pub fn cbmcint(&mut self) -> _CBMCINTW {
                _CBMCINTW { w: self }
            }
            #[doc = "Bit 10 - GPTM Timer B Capture Mode Event Interrupt Clear"]
            #[inline]
            pub fn cbecint(&mut self) -> _CBECINTW {
                _CBECINTW { w: self }
            }
            #[doc = "Bit 11 - GPTM Timer B Match Interrupt Clear"]
            #[inline]
            pub fn tbmcint(&mut self) -> _TBMCINTW {
                _TBMCINTW { w: self }
            }
            #[doc = "Bit 13 - GPTM Timer B DMA Done Interrupt Clear"]
            #[inline]
            pub fn dmabint(&mut self) -> _DMABINTW {
                _DMABINTW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer A Interval Load"]
    pub struct TAILR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Interval Load"]
    pub mod tailr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAILR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPTM Timer B Interval Load"]
    pub struct TBILR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Interval Load"]
    pub mod tbilr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBILR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPTM Timer A Match"]
    pub struct TAMATCHR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Match"]
    pub mod tamatchr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAMATCHR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMRR {
            bits: u32,
        }
        impl TAMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - GPTM Timer A Match Register"]
            #[inline]
            pub fn tamr(&self) -> TAMRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TAMRR { bits }
            }
        }
        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 0:31 - GPTM Timer A Match Register"]
            #[inline]
            pub fn tamr(&mut self) -> _TAMRW {
                _TAMRW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer B Match"]
    pub struct TBMATCHR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Match"]
    pub mod tbmatchr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBMATCHR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMRR {
            bits: u32,
        }
        impl TBMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - GPTM Timer B Match Register"]
            #[inline]
            pub fn tbmr(&self) -> TBMRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TBMRR { bits }
            }
        }
        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 0:31 - GPTM Timer B Match Register"]
            #[inline]
            pub fn tbmr(&mut self) -> _TBMRW {
                _TBMRW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer A Prescale"]
    pub struct TAPR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Prescale"]
    pub mod tapr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAPR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAPSRR {
            bits: u8,
        }
        impl TAPSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAPSRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAPSRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPTM Timer A Prescale"]
            #[inline]
            pub fn tapsr(&self) -> TAPSRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TAPSRR { bits }
            }
        }
        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 0:7 - GPTM Timer A Prescale"]
            #[inline]
            pub fn tapsr(&mut self) -> _TAPSRW {
                _TAPSRW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer B Prescale"]
    pub struct TBPR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Prescale"]
    pub mod tbpr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBPR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBPSRR {
            bits: u8,
        }
        impl TBPSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBPSRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBPSRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPTM Timer B Prescale"]
            #[inline]
            pub fn tbpsr(&self) -> TBPSRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TBPSRR { bits }
            }
        }
        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 0:7 - GPTM Timer B Prescale"]
            #[inline]
            pub fn tbpsr(&mut self) -> _TBPSRW {
                _TBPSRW { w: self }
            }
        }
    }
    #[doc = "GPTM TimerA Prescale Match"]
    pub struct TAPMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM TimerA Prescale Match"]
    pub mod tapmr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAPMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAPSMRR {
            bits: u8,
        }
        impl TAPSMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAPSMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAPSMRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPTM TimerA Prescale Match"]
            #[inline]
            pub fn tapsmr(&self) -> TAPSMRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TAPSMRR { bits }
            }
        }
        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 0:7 - GPTM TimerA Prescale Match"]
            #[inline]
            pub fn tapsmr(&mut self) -> _TAPSMRW {
                _TAPSMRW { w: self }
            }
        }
    }
    #[doc = "GPTM TimerB Prescale Match"]
    pub struct TBPMR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM TimerB Prescale Match"]
    pub mod tbpmr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBPMR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBPSMRR {
            bits: u8,
        }
        impl TBPSMRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBPSMRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBPSMRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPTM TimerB Prescale Match"]
            #[inline]
            pub fn tbpsmr(&self) -> TBPSMRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TBPSMRR { bits }
            }
        }
        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 0:7 - GPTM TimerB Prescale Match"]
            #[inline]
            pub fn tbpsmr(&mut self) -> _TBPSMRW {
                _TBPSMRW { w: self }
            }
        }
    }
    #[doc = "GPTM Timer A"]
    pub struct TAR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A"]
    pub mod tar {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TAR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "GPTM Timer B"]
    pub struct TBR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B"]
    pub mod tbr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TBR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "GPTM Timer A Value"]
    pub struct TAV {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Value"]
    pub mod tav {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TAV {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPTM Timer B Value"]
    pub struct TBV {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Value"]
    pub mod tbv {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TBV {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPTM RTC Predivide"]
    pub struct RTCPD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM RTC Predivide"]
    pub mod rtcpd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RTCPD {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCPDR {
            bits: u16,
        }
        impl RTCPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - RTC Predivide Counter Value"]
            #[inline]
            pub fn rtcpd(&self) -> RTCPDR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RTCPDR { bits }
            }
        }
    }
    #[doc = "GPTM Timer A Prescale Snapshot"]
    pub struct TAPS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer A Prescale Snapshot"]
    pub mod taps {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TAPS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct PSSR {
            bits: u16,
        }
        impl PSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - GPTM Timer A Prescaler Snapshot"]
            #[inline]
            pub fn pss(&self) -> PSSR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                PSSR { bits }
            }
        }
    }
    #[doc = "GPTM Timer B Prescale Snapshot"]
    pub struct TBPS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Timer B Prescale Snapshot"]
    pub mod tbps {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TBPS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct PSSR {
            bits: u16,
        }
        impl PSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"]
            #[inline]
            pub fn pss(&self) -> PSSR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                PSSR { bits }
            }
        }
    }
    #[doc = "GPTM DMA Event"]
    pub struct DMAEV {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM DMA Event"]
    pub mod dmaev {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAEV {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TATODMAENR {
            bits: bool,
        }
        impl TATODMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAMDMAENR {
            bits: bool,
        }
        impl CAMDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAEDMAENR {
            bits: bool,
        }
        impl CAEDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCDMAENR {
            bits: bool,
        }
        impl RTCDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMDMAENR {
            bits: bool,
        }
        impl TAMDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBTODMAENR {
            bits: bool,
        }
        impl TBTODMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBMDMAENR {
            bits: bool,
        }
        impl CBMDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBEDMAENR {
            bits: bool,
        }
        impl CBEDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMDMAENR {
            bits: bool,
        }
        impl TBMDMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TATODMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TATODMAENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAMDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAMDMAENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAEDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAEDMAENW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCDMAENW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMDMAENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBTODMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBTODMAENW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBMDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBMDMAENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBEDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBEDMAENW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMDMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMDMAENW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM A Time-Out Event DMA Trigger Enable"]
            #[inline]
            pub fn tatodmaen(&self) -> TATODMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TATODMAENR { bits }
            }
            #[doc = "Bit 1 - GPTM A Capture Match Event DMA Trigger Enable"]
            #[inline]
            pub fn camdmaen(&self) -> CAMDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAMDMAENR { bits }
            }
            #[doc = "Bit 2 - GPTM A Capture Event DMA Trigger Enable"]
            #[inline]
            pub fn caedmaen(&self) -> CAEDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAEDMAENR { bits }
            }
            #[doc = "Bit 3 - GPTM A RTC Match Event DMA Trigger Enable"]
            #[inline]
            pub fn rtcdmaen(&self) -> RTCDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCDMAENR { bits }
            }
            #[doc = "Bit 4 - GPTM A Mode Match Event DMA Trigger Enable"]
            #[inline]
            pub fn tamdmaen(&self) -> TAMDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMDMAENR { bits }
            }
            #[doc = "Bit 8 - GPTM B Time-Out Event DMA Trigger Enable"]
            #[inline]
            pub fn tbtodmaen(&self) -> TBTODMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBTODMAENR { bits }
            }
            #[doc = "Bit 9 - GPTM B Capture Match Event DMA Trigger Enable"]
            #[inline]
            pub fn cbmdmaen(&self) -> CBMDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBMDMAENR { bits }
            }
            #[doc = "Bit 10 - GPTM B Capture Event DMA Trigger Enable"]
            #[inline]
            pub fn cbedmaen(&self) -> CBEDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBEDMAENR { bits }
            }
            #[doc = "Bit 11 - GPTM B Mode Match Event DMA Trigger Enable"]
            #[inline]
            pub fn tbmdmaen(&self) -> TBMDMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMDMAENR { bits }
            }
        }
        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 = "Bit 0 - GPTM A Time-Out Event DMA Trigger Enable"]
            #[inline]
            pub fn tatodmaen(&mut self) -> _TATODMAENW {
                _TATODMAENW { w: self }
            }
            #[doc = "Bit 1 - GPTM A Capture Match Event DMA Trigger Enable"]
            #[inline]
            pub fn camdmaen(&mut self) -> _CAMDMAENW {
                _CAMDMAENW { w: self }
            }
            #[doc = "Bit 2 - GPTM A Capture Event DMA Trigger Enable"]
            #[inline]
            pub fn caedmaen(&mut self) -> _CAEDMAENW {
                _CAEDMAENW { w: self }
            }
            #[doc = "Bit 3 - GPTM A RTC Match Event DMA Trigger Enable"]
            #[inline]
            pub fn rtcdmaen(&mut self) -> _RTCDMAENW {
                _RTCDMAENW { w: self }
            }
            #[doc = "Bit 4 - GPTM A Mode Match Event DMA Trigger Enable"]
            #[inline]
            pub fn tamdmaen(&mut self) -> _TAMDMAENW {
                _TAMDMAENW { w: self }
            }
            #[doc = "Bit 8 - GPTM B Time-Out Event DMA Trigger Enable"]
            #[inline]
            pub fn tbtodmaen(&mut self) -> _TBTODMAENW {
                _TBTODMAENW { w: self }
            }
            #[doc = "Bit 9 - GPTM B Capture Match Event DMA Trigger Enable"]
            #[inline]
            pub fn cbmdmaen(&mut self) -> _CBMDMAENW {
                _CBMDMAENW { w: self }
            }
            #[doc = "Bit 10 - GPTM B Capture Event DMA Trigger Enable"]
            #[inline]
            pub fn cbedmaen(&mut self) -> _CBEDMAENW {
                _CBEDMAENW { w: self }
            }
            #[doc = "Bit 11 - GPTM B Mode Match Event DMA Trigger Enable"]
            #[inline]
            pub fn tbmdmaen(&mut self) -> _TBMDMAENW {
                _TBMDMAENW { w: self }
            }
        }
    }
    #[doc = "GPTM ADC Event"]
    pub struct ADCEV {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM ADC Event"]
    pub mod adcev {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADCEV {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TATOADCENR {
            bits: bool,
        }
        impl TATOADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAMADCENR {
            bits: bool,
        }
        impl CAMADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAEADCENR {
            bits: bool,
        }
        impl CAEADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCADCENR {
            bits: bool,
        }
        impl RTCADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMADCENR {
            bits: bool,
        }
        impl TAMADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBTOADCENR {
            bits: bool,
        }
        impl TBTOADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBMADCENR {
            bits: bool,
        }
        impl CBMADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CBEADCENR {
            bits: bool,
        }
        impl CBEADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TBMADCENR {
            bits: bool,
        }
        impl TBMADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TATOADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TATOADCENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAMADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAMADCENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAEADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAEADCENW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCADCENW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMADCENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBTOADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBTOADCENW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBMADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBMADCENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CBEADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CBEADCENW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TBMADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TBMADCENW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPTM A Time-Out Event ADC Trigger Enable"]
            #[inline]
            pub fn tatoadcen(&self) -> TATOADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TATOADCENR { bits }
            }
            #[doc = "Bit 1 - GPTM A Capture Match Event ADC Trigger Enable"]
            #[inline]
            pub fn camadcen(&self) -> CAMADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAMADCENR { bits }
            }
            #[doc = "Bit 2 - GPTM A Capture Event ADC Trigger Enable"]
            #[inline]
            pub fn caeadcen(&self) -> CAEADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAEADCENR { bits }
            }
            #[doc = "Bit 3 - GPTM RTC Match Event ADC Trigger Enable"]
            #[inline]
            pub fn rtcadcen(&self) -> RTCADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCADCENR { bits }
            }
            #[doc = "Bit 4 - GPTM A Mode Match Event ADC Trigger Enable"]
            #[inline]
            pub fn tamadcen(&self) -> TAMADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMADCENR { bits }
            }
            #[doc = "Bit 8 - GPTM B Time-Out Event ADC Trigger Enable"]
            #[inline]
            pub fn tbtoadcen(&self) -> TBTOADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBTOADCENR { bits }
            }
            #[doc = "Bit 9 - GPTM B Capture Match Event ADC Trigger Enable"]
            #[inline]
            pub fn cbmadcen(&self) -> CBMADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBMADCENR { bits }
            }
            #[doc = "Bit 10 - GPTM B Capture Event ADC Trigger Enable"]
            #[inline]
            pub fn cbeadcen(&self) -> CBEADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CBEADCENR { bits }
            }
            #[doc = "Bit 11 - GPTM B Mode Match Event ADC Trigger Enable"]
            #[inline]
            pub fn tbmadcen(&self) -> TBMADCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TBMADCENR { bits }
            }
        }
        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 = "Bit 0 - GPTM A Time-Out Event ADC Trigger Enable"]
            #[inline]
            pub fn tatoadcen(&mut self) -> _TATOADCENW {
                _TATOADCENW { w: self }
            }
            #[doc = "Bit 1 - GPTM A Capture Match Event ADC Trigger Enable"]
            #[inline]
            pub fn camadcen(&mut self) -> _CAMADCENW {
                _CAMADCENW { w: self }
            }
            #[doc = "Bit 2 - GPTM A Capture Event ADC Trigger Enable"]
            #[inline]
            pub fn caeadcen(&mut self) -> _CAEADCENW {
                _CAEADCENW { w: self }
            }
            #[doc = "Bit 3 - GPTM RTC Match Event ADC Trigger Enable"]
            #[inline]
            pub fn rtcadcen(&mut self) -> _RTCADCENW {
                _RTCADCENW { w: self }
            }
            #[doc = "Bit 4 - GPTM A Mode Match Event ADC Trigger Enable"]
            #[inline]
            pub fn tamadcen(&mut self) -> _TAMADCENW {
                _TAMADCENW { w: self }
            }
            #[doc = "Bit 8 - GPTM B Time-Out Event ADC Trigger Enable"]
            #[inline]
            pub fn tbtoadcen(&mut self) -> _TBTOADCENW {
                _TBTOADCENW { w: self }
            }
            #[doc = "Bit 9 - GPTM B Capture Match Event ADC Trigger Enable"]
            #[inline]
            pub fn cbmadcen(&mut self) -> _CBMADCENW {
                _CBMADCENW { w: self }
            }
            #[doc = "Bit 10 - GPTM B Capture Event ADC Trigger Enable"]
            #[inline]
            pub fn cbeadcen(&mut self) -> _CBEADCENW {
                _CBEADCENW { w: self }
            }
            #[doc = "Bit 11 - GPTM B Mode Match Event ADC Trigger Enable"]
            #[inline]
            pub fn tbmadcen(&mut self) -> _TBMADCENW {
                _TBMADCENW { w: self }
            }
        }
    }
    #[doc = "GPTM Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "Timer A and Timer B counters are 16 bits each with an 8-bit prescale counter"]
            _16,
            #[doc = "Timer A and Timer B counters are 32 bits each with a 16-bit prescale counter"]
            _32,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_16 => 0,
                    SIZER::_32 => 0x01,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    0 => SIZER::_16,
                    1 => SIZER::_32,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == SIZER::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == SIZER::_32
            }
        }
        #[doc = r" Value of the field"]
        pub struct CHAINR {
            bits: bool,
        }
        impl CHAINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNCCNTR {
            bits: bool,
        }
        impl SYNCCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALTCLKR {
            bits: bool,
        }
        impl ALTCLKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Count Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Chain with Other Timers"]
            #[inline]
            pub fn chain(&self) -> CHAINR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CHAINR { bits }
            }
            #[doc = "Bit 5 - Synchronize Start"]
            #[inline]
            pub fn synccnt(&self) -> SYNCCNTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNCCNTR { bits }
            }
            #[doc = "Bit 6 - Alternate Clock Source"]
            #[inline]
            pub fn altclk(&self) -> ALTCLKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALTCLKR { bits }
            }
        }
    }
    #[doc = "GPTM Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPTM Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALTCLKR {
            bits: bool,
        }
        impl ALTCLKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALTCLKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALTCLKW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Alternate Clock Source"]
            #[inline]
            pub fn altclk(&self) -> ALTCLKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALTCLKR { bits }
            }
        }
        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 = "Bit 0 - Alternate Clock Source"]
            #[inline]
            pub fn altclk(&mut self) -> _ALTCLKW {
                _ALTCLKW { w: self }
            }
        }
    }
}
#[doc = "TIMER1"]
pub struct TIMER1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER1 {}
impl TIMER1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_1000 as *const _
    }
}
impl Deref for TIMER1 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER1::ptr() }
    }
}
#[doc = "TIMER2"]
pub struct TIMER2 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER2 {}
impl TIMER2 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_2000 as *const _
    }
}
impl Deref for TIMER2 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER2::ptr() }
    }
}
#[doc = "TIMER3"]
pub struct TIMER3 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER3 {}
impl TIMER3 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_3000 as *const _
    }
}
impl Deref for TIMER3 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER3::ptr() }
    }
}
#[doc = "TIMER4"]
pub struct TIMER4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER4 {}
impl TIMER4 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_4000 as *const _
    }
}
impl Deref for TIMER4 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER4::ptr() }
    }
}
#[doc = "TIMER5"]
pub struct TIMER5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER5 {}
impl TIMER5 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x4003_5000 as *const _
    }
}
impl Deref for TIMER5 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER5::ptr() }
    }
}
#[doc = "ADC register offsets"]
pub struct ADC0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC0 {}
impl ADC0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const adc0::RegisterBlock {
        0x4003_8000 as *const _
    }
}
impl Deref for ADC0 {
    type Target = adc0::RegisterBlock;
    fn deref(&self) -> &adc0::RegisterBlock {
        unsafe { &*ADC0::ptr() }
    }
}
#[doc = "ADC register offsets"]
pub mod adc0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - ADC Active Sample Sequencer"]
        pub actss: ACTSS,
        #[doc = "0x04 - ADC Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x08 - ADC Interrupt Mask"]
        pub im: IM,
        #[doc = "0x0c - ADC Interrupt Status and Clear"]
        pub isc: ISC,
        #[doc = "0x10 - ADC Overflow Status"]
        pub ostat: OSTAT,
        #[doc = "0x14 - ADC Event Multiplexer Select"]
        pub emux: EMUX,
        #[doc = "0x18 - ADC Underflow Status"]
        pub ustat: USTAT,
        #[doc = "0x1c - ADC Trigger Source Select"]
        pub tssel: TSSEL,
        #[doc = "0x20 - ADC Sample Sequencer Priority"]
        pub sspri: SSPRI,
        #[doc = "0x24 - ADC Sample Phase Control"]
        pub spc: SPC,
        #[doc = "0x28 - ADC Processor Sample Sequence Initiate"]
        pub pssi: PSSI,
        _reserved0: [u8; 4usize],
        #[doc = "0x30 - ADC Sample Averaging Control"]
        pub sac: SAC,
        #[doc = "0x34 - ADC Digital Comparator Interrupt Status and Clear"]
        pub dcisc: DCISC,
        #[doc = "0x38 - ADC Control"]
        pub ctl: CTL,
        _reserved1: [u8; 4usize],
        #[doc = "0x40 - ADC Sample Sequence Input Multiplexer Select 0"]
        pub ssmux0: SSMUX0,
        #[doc = "0x44 - ADC Sample Sequence Control 0"]
        pub ssctl0: SSCTL0,
        #[doc = "0x48 - ADC Sample Sequence Result FIFO 0"]
        pub ssfifo0: SSFIFO0,
        #[doc = "0x4c - ADC Sample Sequence FIFO 0 Status"]
        pub ssfstat0: SSFSTAT0,
        #[doc = "0x50 - ADC Sample Sequence 0 Operation"]
        pub ssop0: SSOP0,
        #[doc = "0x54 - ADC Sample Sequence 0 Digital Comparator Select"]
        pub ssdc0: SSDC0,
        #[doc = "0x58 - ADC Sample Sequence Extended Input Multiplexer Select 0"]
        pub ssemux0: SSEMUX0,
        #[doc = "0x5c - ADC Sample Sequence 0 Sample and Hold Time"]
        pub sstsh0: SSTSH0,
        #[doc = "0x60 - ADC Sample Sequence Input Multiplexer Select 1"]
        pub ssmux1: SSMUX1,
        #[doc = "0x64 - ADC Sample Sequence Control 1"]
        pub ssctl1: SSCTL1,
        #[doc = "0x68 - ADC Sample Sequence Result FIFO 1"]
        pub ssfifo1: SSFIFO1,
        #[doc = "0x6c - ADC Sample Sequence FIFO 1 Status"]
        pub ssfstat1: SSFSTAT1,
        #[doc = "0x70 - ADC Sample Sequence 1 Operation"]
        pub ssop1: SSOP1,
        #[doc = "0x74 - ADC Sample Sequence 1 Digital Comparator Select"]
        pub ssdc1: SSDC1,
        #[doc = "0x78 - ADC Sample Sequence Extended Input Multiplexer Select 1"]
        pub ssemux1: SSEMUX1,
        #[doc = "0x7c - ADC Sample Sequence 1 Sample and Hold Time"]
        pub sstsh1: SSTSH1,
        #[doc = "0x80 - ADC Sample Sequence Input Multiplexer Select 2"]
        pub ssmux2: SSMUX2,
        #[doc = "0x84 - ADC Sample Sequence Control 2"]
        pub ssctl2: SSCTL2,
        #[doc = "0x88 - ADC Sample Sequence Result FIFO 2"]
        pub ssfifo2: SSFIFO2,
        #[doc = "0x8c - ADC Sample Sequence FIFO 2 Status"]
        pub ssfstat2: SSFSTAT2,
        #[doc = "0x90 - ADC Sample Sequence 2 Operation"]
        pub ssop2: SSOP2,
        #[doc = "0x94 - ADC Sample Sequence 2 Digital Comparator Select"]
        pub ssdc2: SSDC2,
        #[doc = "0x98 - ADC Sample Sequence Extended Input Multiplexer Select 2"]
        pub ssemux2: SSEMUX2,
        #[doc = "0x9c - ADC Sample Sequence 2 Sample and Hold Time"]
        pub sstsh2: SSTSH2,
        #[doc = "0xa0 - ADC Sample Sequence Input Multiplexer Select 3"]
        pub ssmux3: SSMUX3,
        #[doc = "0xa4 - ADC Sample Sequence Control 3"]
        pub ssctl3: SSCTL3,
        #[doc = "0xa8 - ADC Sample Sequence Result FIFO 3"]
        pub ssfifo3: SSFIFO3,
        #[doc = "0xac - ADC Sample Sequence FIFO 3 Status"]
        pub ssfstat3: SSFSTAT3,
        #[doc = "0xb0 - ADC Sample Sequence 3 Operation"]
        pub ssop3: SSOP3,
        #[doc = "0xb4 - ADC Sample Sequence 3 Digital Comparator Select"]
        pub ssdc3: SSDC3,
        #[doc = "0xb8 - ADC Sample Sequence Extended Input Multiplexer Select 3"]
        pub ssemux3: SSEMUX3,
        #[doc = "0xbc - ADC Sample Sequence 3 Sample and Hold Time"]
        pub sstsh3: SSTSH3,
        _reserved2: [u8; 3136usize],
        #[doc = "0xd00 - ADC Digital Comparator Reset Initial Conditions"]
        pub dcric: DCRIC,
        _reserved3: [u8; 252usize],
        #[doc = "0xe00 - ADC Digital Comparator Control 0"]
        pub dcctl0: DCCTL0,
        #[doc = "0xe04 - ADC Digital Comparator Control 1"]
        pub dcctl1: DCCTL1,
        #[doc = "0xe08 - ADC Digital Comparator Control 2"]
        pub dcctl2: DCCTL2,
        #[doc = "0xe0c - ADC Digital Comparator Control 3"]
        pub dcctl3: DCCTL3,
        #[doc = "0xe10 - ADC Digital Comparator Control 4"]
        pub dcctl4: DCCTL4,
        #[doc = "0xe14 - ADC Digital Comparator Control 5"]
        pub dcctl5: DCCTL5,
        #[doc = "0xe18 - ADC Digital Comparator Control 6"]
        pub dcctl6: DCCTL6,
        #[doc = "0xe1c - ADC Digital Comparator Control 7"]
        pub dcctl7: DCCTL7,
        _reserved4: [u8; 32usize],
        #[doc = "0xe40 - ADC Digital Comparator Range 0"]
        pub dccmp0: DCCMP0,
        #[doc = "0xe44 - ADC Digital Comparator Range 1"]
        pub dccmp1: DCCMP1,
        #[doc = "0xe48 - ADC Digital Comparator Range 2"]
        pub dccmp2: DCCMP2,
        #[doc = "0xe4c - ADC Digital Comparator Range 3"]
        pub dccmp3: DCCMP3,
        #[doc = "0xe50 - ADC Digital Comparator Range 4"]
        pub dccmp4: DCCMP4,
        #[doc = "0xe54 - ADC Digital Comparator Range 5"]
        pub dccmp5: DCCMP5,
        #[doc = "0xe58 - ADC Digital Comparator Range 6"]
        pub dccmp6: DCCMP6,
        #[doc = "0xe5c - ADC Digital Comparator Range 7"]
        pub dccmp7: DCCMP7,
        _reserved5: [u8; 352usize],
        #[doc = "0xfc0 - ADC Peripheral Properties"]
        pub pp: PP,
        #[doc = "0xfc4 - ADC Peripheral Configuration"]
        pub pc: PC,
        #[doc = "0xfc8 - ADC Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "ADC Active Sample Sequencer"]
    pub struct ACTSS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Active Sample Sequencer"]
    pub mod actss {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACTSS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ASEN0R {
            bits: bool,
        }
        impl ASEN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ASEN1R {
            bits: bool,
        }
        impl ASEN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ASEN2R {
            bits: bool,
        }
        impl ASEN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ASEN3R {
            bits: bool,
        }
        impl ASEN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADEN0R {
            bits: bool,
        }
        impl ADEN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADEN1R {
            bits: bool,
        }
        impl ADEN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADEN2R {
            bits: bool,
        }
        impl ADEN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADEN3R {
            bits: bool,
        }
        impl ADEN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSYR {
            bits: bool,
        }
        impl BUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASEN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASEN0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASEN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASEN1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASEN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASEN2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASEN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASEN3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADEN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADEN0W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADEN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADEN1W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADEN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADEN2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADEN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADEN3W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BUSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BUSYW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC SS0 Enable"]
            #[inline]
            pub fn asen0(&self) -> ASEN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ASEN0R { bits }
            }
            #[doc = "Bit 1 - ADC SS1 Enable"]
            #[inline]
            pub fn asen1(&self) -> ASEN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ASEN1R { bits }
            }
            #[doc = "Bit 2 - ADC SS2 Enable"]
            #[inline]
            pub fn asen2(&self) -> ASEN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ASEN2R { bits }
            }
            #[doc = "Bit 3 - ADC SS3 Enable"]
            #[inline]
            pub fn asen3(&self) -> ASEN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ASEN3R { bits }
            }
            #[doc = "Bit 8 - ADC SS1 DMA Enable"]
            #[inline]
            pub fn aden0(&self) -> ADEN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADEN0R { bits }
            }
            #[doc = "Bit 9 - ADC SS1 DMA Enable"]
            #[inline]
            pub fn aden1(&self) -> ADEN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADEN1R { bits }
            }
            #[doc = "Bit 10 - ADC SS2 DMA Enable"]
            #[inline]
            pub fn aden2(&self) -> ADEN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADEN2R { bits }
            }
            #[doc = "Bit 11 - ADC SS3 DMA Enable"]
            #[inline]
            pub fn aden3(&self) -> ADEN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADEN3R { bits }
            }
            #[doc = "Bit 16 - ADC Busy"]
            #[inline]
            pub fn busy(&self) -> BUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSYR { bits }
            }
        }
        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 = "Bit 0 - ADC SS0 Enable"]
            #[inline]
            pub fn asen0(&mut self) -> _ASEN0W {
                _ASEN0W { w: self }
            }
            #[doc = "Bit 1 - ADC SS1 Enable"]
            #[inline]
            pub fn asen1(&mut self) -> _ASEN1W {
                _ASEN1W { w: self }
            }
            #[doc = "Bit 2 - ADC SS2 Enable"]
            #[inline]
            pub fn asen2(&mut self) -> _ASEN2W {
                _ASEN2W { w: self }
            }
            #[doc = "Bit 3 - ADC SS3 Enable"]
            #[inline]
            pub fn asen3(&mut self) -> _ASEN3W {
                _ASEN3W { w: self }
            }
            #[doc = "Bit 8 - ADC SS1 DMA Enable"]
            #[inline]
            pub fn aden0(&mut self) -> _ADEN0W {
                _ADEN0W { w: self }
            }
            #[doc = "Bit 9 - ADC SS1 DMA Enable"]
            #[inline]
            pub fn aden1(&mut self) -> _ADEN1W {
                _ADEN1W { w: self }
            }
            #[doc = "Bit 10 - ADC SS2 DMA Enable"]
            #[inline]
            pub fn aden2(&mut self) -> _ADEN2W {
                _ADEN2W { w: self }
            }
            #[doc = "Bit 11 - ADC SS3 DMA Enable"]
            #[inline]
            pub fn aden3(&mut self) -> _ADEN3W {
                _ADEN3W { w: self }
            }
            #[doc = "Bit 16 - ADC Busy"]
            #[inline]
            pub fn busy(&mut self) -> _BUSYW {
                _BUSYW { w: self }
            }
        }
    }
    #[doc = "ADC Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INR0R {
            bits: bool,
        }
        impl INR0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INR1R {
            bits: bool,
        }
        impl INR1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INR2R {
            bits: bool,
        }
        impl INR2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INR3R {
            bits: bool,
        }
        impl INR3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAINR0R {
            bits: bool,
        }
        impl DMAINR0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAINR1R {
            bits: bool,
        }
        impl DMAINR1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAINR2R {
            bits: bool,
        }
        impl DMAINR2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAINR3R {
            bits: bool,
        }
        impl DMAINR3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INRDCR {
            bits: bool,
        }
        impl INRDCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 Raw Interrupt Status"]
            #[inline]
            pub fn inr0(&self) -> INR0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INR0R { bits }
            }
            #[doc = "Bit 1 - SS1 Raw Interrupt Status"]
            #[inline]
            pub fn inr1(&self) -> INR1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INR1R { bits }
            }
            #[doc = "Bit 2 - SS2 Raw Interrupt Status"]
            #[inline]
            pub fn inr2(&self) -> INR2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INR2R { bits }
            }
            #[doc = "Bit 3 - SS3 Raw Interrupt Status"]
            #[inline]
            pub fn inr3(&self) -> INR3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INR3R { bits }
            }
            #[doc = "Bit 8 - SS0 DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmainr0(&self) -> DMAINR0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAINR0R { bits }
            }
            #[doc = "Bit 9 - SS1 DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmainr1(&self) -> DMAINR1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAINR1R { bits }
            }
            #[doc = "Bit 10 - SS2 DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmainr2(&self) -> DMAINR2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAINR2R { bits }
            }
            #[doc = "Bit 11 - SS3 DMA Raw Interrupt Status"]
            #[inline]
            pub fn dmainr3(&self) -> DMAINR3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAINR3R { bits }
            }
            #[doc = "Bit 16 - Digital Comparator Raw Interrupt Status"]
            #[inline]
            pub fn inrdc(&self) -> INRDCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INRDCR { bits }
            }
        }
    }
    #[doc = "ADC Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASK0R {
            bits: bool,
        }
        impl MASK0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASK1R {
            bits: bool,
        }
        impl MASK1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASK2R {
            bits: bool,
        }
        impl MASK2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASK3R {
            bits: bool,
        }
        impl MASK3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMASK0R {
            bits: bool,
        }
        impl DMAMASK0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMASK1R {
            bits: bool,
        }
        impl DMAMASK1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMASK2R {
            bits: bool,
        }
        impl DMAMASK2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMASK3R {
            bits: bool,
        }
        impl DMAMASK3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCONSS0R {
            bits: bool,
        }
        impl DCONSS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCONSS1R {
            bits: bool,
        }
        impl DCONSS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCONSS2R {
            bits: bool,
        }
        impl DCONSS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCONSS3R {
            bits: bool,
        }
        impl DCONSS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASK0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASK0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASK1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASK1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASK2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASK2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASK3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASK3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMASK0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMASK0W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMASK1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMASK1W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMASK2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMASK2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMASK3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMASK3W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCONSS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCONSS0W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCONSS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCONSS1W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCONSS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCONSS2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCONSS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCONSS3W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 Interrupt Mask"]
            #[inline]
            pub fn mask0(&self) -> MASK0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASK0R { bits }
            }
            #[doc = "Bit 1 - SS1 Interrupt Mask"]
            #[inline]
            pub fn mask1(&self) -> MASK1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASK1R { bits }
            }
            #[doc = "Bit 2 - SS2 Interrupt Mask"]
            #[inline]
            pub fn mask2(&self) -> MASK2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASK2R { bits }
            }
            #[doc = "Bit 3 - SS3 Interrupt Mask"]
            #[inline]
            pub fn mask3(&self) -> MASK3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASK3R { bits }
            }
            #[doc = "Bit 8 - SS0 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask0(&self) -> DMAMASK0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAMASK0R { bits }
            }
            #[doc = "Bit 9 - SS1 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask1(&self) -> DMAMASK1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAMASK1R { bits }
            }
            #[doc = "Bit 10 - SS2 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask2(&self) -> DMAMASK2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAMASK2R { bits }
            }
            #[doc = "Bit 11 - SS3 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask3(&self) -> DMAMASK3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAMASK3R { bits }
            }
            #[doc = "Bit 16 - Digital Comparator Interrupt on SS0"]
            #[inline]
            pub fn dconss0(&self) -> DCONSS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCONSS0R { bits }
            }
            #[doc = "Bit 17 - Digital Comparator Interrupt on SS1"]
            #[inline]
            pub fn dconss1(&self) -> DCONSS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCONSS1R { bits }
            }
            #[doc = "Bit 18 - Digital Comparator Interrupt on SS2"]
            #[inline]
            pub fn dconss2(&self) -> DCONSS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCONSS2R { bits }
            }
            #[doc = "Bit 19 - Digital Comparator Interrupt on SS3"]
            #[inline]
            pub fn dconss3(&self) -> DCONSS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCONSS3R { bits }
            }
        }
        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 = "Bit 0 - SS0 Interrupt Mask"]
            #[inline]
            pub fn mask0(&mut self) -> _MASK0W {
                _MASK0W { w: self }
            }
            #[doc = "Bit 1 - SS1 Interrupt Mask"]
            #[inline]
            pub fn mask1(&mut self) -> _MASK1W {
                _MASK1W { w: self }
            }
            #[doc = "Bit 2 - SS2 Interrupt Mask"]
            #[inline]
            pub fn mask2(&mut self) -> _MASK2W {
                _MASK2W { w: self }
            }
            #[doc = "Bit 3 - SS3 Interrupt Mask"]
            #[inline]
            pub fn mask3(&mut self) -> _MASK3W {
                _MASK3W { w: self }
            }
            #[doc = "Bit 8 - SS0 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask0(&mut self) -> _DMAMASK0W {
                _DMAMASK0W { w: self }
            }
            #[doc = "Bit 9 - SS1 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask1(&mut self) -> _DMAMASK1W {
                _DMAMASK1W { w: self }
            }
            #[doc = "Bit 10 - SS2 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask2(&mut self) -> _DMAMASK2W {
                _DMAMASK2W { w: self }
            }
            #[doc = "Bit 11 - SS3 DMA Interrupt Mask"]
            #[inline]
            pub fn dmamask3(&mut self) -> _DMAMASK3W {
                _DMAMASK3W { w: self }
            }
            #[doc = "Bit 16 - Digital Comparator Interrupt on SS0"]
            #[inline]
            pub fn dconss0(&mut self) -> _DCONSS0W {
                _DCONSS0W { w: self }
            }
            #[doc = "Bit 17 - Digital Comparator Interrupt on SS1"]
            #[inline]
            pub fn dconss1(&mut self) -> _DCONSS1W {
                _DCONSS1W { w: self }
            }
            #[doc = "Bit 18 - Digital Comparator Interrupt on SS2"]
            #[inline]
            pub fn dconss2(&mut self) -> _DCONSS2W {
                _DCONSS2W { w: self }
            }
            #[doc = "Bit 19 - Digital Comparator Interrupt on SS3"]
            #[inline]
            pub fn dconss3(&mut self) -> _DCONSS3W {
                _DCONSS3W { w: self }
            }
        }
    }
    #[doc = "ADC Interrupt Status and Clear"]
    pub struct ISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Interrupt Status and Clear"]
    pub mod isc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN0R {
            bits: bool,
        }
        impl IN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN1R {
            bits: bool,
        }
        impl IN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN2R {
            bits: bool,
        }
        impl IN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN3R {
            bits: bool,
        }
        impl IN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAIN0R {
            bits: bool,
        }
        impl DMAIN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAIN1R {
            bits: bool,
        }
        impl DMAIN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAIN2R {
            bits: bool,
        }
        impl DMAIN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAIN3R {
            bits: bool,
        }
        impl DMAIN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINSS0R {
            bits: bool,
        }
        impl DCINSS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINSS1R {
            bits: bool,
        }
        impl DCINSS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINSS2R {
            bits: bool,
        }
        impl DCINSS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINSS3R {
            bits: bool,
        }
        impl DCINSS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAIN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAIN0W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAIN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAIN1W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAIN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAIN2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAIN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAIN3W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINSS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINSS0W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINSS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINSS1W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINSS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINSS2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINSS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINSS3W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 Interrupt Status and Clear"]
            #[inline]
            pub fn in0(&self) -> IN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN0R { bits }
            }
            #[doc = "Bit 1 - SS1 Interrupt Status and Clear"]
            #[inline]
            pub fn in1(&self) -> IN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN1R { bits }
            }
            #[doc = "Bit 2 - SS2 Interrupt Status and Clear"]
            #[inline]
            pub fn in2(&self) -> IN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN2R { bits }
            }
            #[doc = "Bit 3 - SS3 Interrupt Status and Clear"]
            #[inline]
            pub fn in3(&self) -> IN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN3R { bits }
            }
            #[doc = "Bit 8 - SS0 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain0(&self) -> DMAIN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAIN0R { bits }
            }
            #[doc = "Bit 9 - SS1 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain1(&self) -> DMAIN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAIN1R { bits }
            }
            #[doc = "Bit 10 - SS2 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain2(&self) -> DMAIN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAIN2R { bits }
            }
            #[doc = "Bit 11 - SS3 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain3(&self) -> DMAIN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAIN3R { bits }
            }
            #[doc = "Bit 16 - Digital Comparator Interrupt Status on SS0"]
            #[inline]
            pub fn dcinss0(&self) -> DCINSS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINSS0R { bits }
            }
            #[doc = "Bit 17 - Digital Comparator Interrupt Status on SS1"]
            #[inline]
            pub fn dcinss1(&self) -> DCINSS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINSS1R { bits }
            }
            #[doc = "Bit 18 - Digital Comparator Interrupt Status on SS2"]
            #[inline]
            pub fn dcinss2(&self) -> DCINSS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINSS2R { bits }
            }
            #[doc = "Bit 19 - Digital Comparator Interrupt Status on SS3"]
            #[inline]
            pub fn dcinss3(&self) -> DCINSS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINSS3R { bits }
            }
        }
        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 = "Bit 0 - SS0 Interrupt Status and Clear"]
            #[inline]
            pub fn in0(&mut self) -> _IN0W {
                _IN0W { w: self }
            }
            #[doc = "Bit 1 - SS1 Interrupt Status and Clear"]
            #[inline]
            pub fn in1(&mut self) -> _IN1W {
                _IN1W { w: self }
            }
            #[doc = "Bit 2 - SS2 Interrupt Status and Clear"]
            #[inline]
            pub fn in2(&mut self) -> _IN2W {
                _IN2W { w: self }
            }
            #[doc = "Bit 3 - SS3 Interrupt Status and Clear"]
            #[inline]
            pub fn in3(&mut self) -> _IN3W {
                _IN3W { w: self }
            }
            #[doc = "Bit 8 - SS0 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain0(&mut self) -> _DMAIN0W {
                _DMAIN0W { w: self }
            }
            #[doc = "Bit 9 - SS1 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain1(&mut self) -> _DMAIN1W {
                _DMAIN1W { w: self }
            }
            #[doc = "Bit 10 - SS2 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain2(&mut self) -> _DMAIN2W {
                _DMAIN2W { w: self }
            }
            #[doc = "Bit 11 - SS3 DMA Interrupt Status and Clear"]
            #[inline]
            pub fn dmain3(&mut self) -> _DMAIN3W {
                _DMAIN3W { w: self }
            }
            #[doc = "Bit 16 - Digital Comparator Interrupt Status on SS0"]
            #[inline]
            pub fn dcinss0(&mut self) -> _DCINSS0W {
                _DCINSS0W { w: self }
            }
            #[doc = "Bit 17 - Digital Comparator Interrupt Status on SS1"]
            #[inline]
            pub fn dcinss1(&mut self) -> _DCINSS1W {
                _DCINSS1W { w: self }
            }
            #[doc = "Bit 18 - Digital Comparator Interrupt Status on SS2"]
            #[inline]
            pub fn dcinss2(&mut self) -> _DCINSS2W {
                _DCINSS2W { w: self }
            }
            #[doc = "Bit 19 - Digital Comparator Interrupt Status on SS3"]
            #[inline]
            pub fn dcinss3(&mut self) -> _DCINSS3W {
                _DCINSS3W { w: self }
            }
        }
    }
    #[doc = "ADC Overflow Status"]
    pub struct OSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Overflow Status"]
    pub mod ostat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::OSTAT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct OV0R {
            bits: bool,
        }
        impl OV0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OV1R {
            bits: bool,
        }
        impl OV1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OV2R {
            bits: bool,
        }
        impl OV2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OV3R {
            bits: bool,
        }
        impl OV3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _OV0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _OV0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _OV1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _OV1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OV2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _OV2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OV3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _OV3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 FIFO Overflow"]
            #[inline]
            pub fn ov0(&self) -> OV0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OV0R { bits }
            }
            #[doc = "Bit 1 - SS1 FIFO Overflow"]
            #[inline]
            pub fn ov1(&self) -> OV1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OV1R { bits }
            }
            #[doc = "Bit 2 - SS2 FIFO Overflow"]
            #[inline]
            pub fn ov2(&self) -> OV2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OV2R { bits }
            }
            #[doc = "Bit 3 - SS3 FIFO Overflow"]
            #[inline]
            pub fn ov3(&self) -> OV3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OV3R { bits }
            }
        }
        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 = "Bit 0 - SS0 FIFO Overflow"]
            #[inline]
            pub fn ov0(&mut self) -> _OV0W {
                _OV0W { w: self }
            }
            #[doc = "Bit 1 - SS1 FIFO Overflow"]
            #[inline]
            pub fn ov1(&mut self) -> _OV1W {
                _OV1W { w: self }
            }
            #[doc = "Bit 2 - SS2 FIFO Overflow"]
            #[inline]
            pub fn ov2(&mut self) -> _OV2W {
                _OV2W { w: self }
            }
            #[doc = "Bit 3 - SS3 FIFO Overflow"]
            #[inline]
            pub fn ov3(&mut self) -> _OV3W {
                _OV3W { w: self }
            }
        }
    }
    #[doc = "ADC Event Multiplexer Select"]
    pub struct EMUX {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Event Multiplexer Select"]
    pub mod emux {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EMUX {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `EM0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EM0R {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EM0R::PROCESSOR => 0,
                    EM0R::COMP0 => 0x01,
                    EM0R::COMP1 => 0x02,
                    EM0R::COMP2 => 0x03,
                    EM0R::EXTERNAL => 0x04,
                    EM0R::TIMER => 0x05,
                    EM0R::PWM0 => 0x06,
                    EM0R::PWM1 => 0x07,
                    EM0R::PWM2 => 0x08,
                    EM0R::PWM3 => 0x09,
                    EM0R::NEVER => 0x0e,
                    EM0R::ALWAYS => 0x0f,
                    EM0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EM0R {
                match value {
                    0 => EM0R::PROCESSOR,
                    1 => EM0R::COMP0,
                    2 => EM0R::COMP1,
                    3 => EM0R::COMP2,
                    4 => EM0R::EXTERNAL,
                    5 => EM0R::TIMER,
                    6 => EM0R::PWM0,
                    7 => EM0R::PWM1,
                    8 => EM0R::PWM2,
                    9 => EM0R::PWM3,
                    14 => EM0R::NEVER,
                    15 => EM0R::ALWAYS,
                    i => EM0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PROCESSOR`"]
            #[inline]
            pub fn is_processor(&self) -> bool {
                *self == EM0R::PROCESSOR
            }
            #[doc = "Checks if the value of the field is `COMP0`"]
            #[inline]
            pub fn is_comp0(&self) -> bool {
                *self == EM0R::COMP0
            }
            #[doc = "Checks if the value of the field is `COMP1`"]
            #[inline]
            pub fn is_comp1(&self) -> bool {
                *self == EM0R::COMP1
            }
            #[doc = "Checks if the value of the field is `COMP2`"]
            #[inline]
            pub fn is_comp2(&self) -> bool {
                *self == EM0R::COMP2
            }
            #[doc = "Checks if the value of the field is `EXTERNAL`"]
            #[inline]
            pub fn is_external(&self) -> bool {
                *self == EM0R::EXTERNAL
            }
            #[doc = "Checks if the value of the field is `TIMER`"]
            #[inline]
            pub fn is_timer(&self) -> bool {
                *self == EM0R::TIMER
            }
            #[doc = "Checks if the value of the field is `PWM0`"]
            #[inline]
            pub fn is_pwm0(&self) -> bool {
                *self == EM0R::PWM0
            }
            #[doc = "Checks if the value of the field is `PWM1`"]
            #[inline]
            pub fn is_pwm1(&self) -> bool {
                *self == EM0R::PWM1
            }
            #[doc = "Checks if the value of the field is `PWM2`"]
            #[inline]
            pub fn is_pwm2(&self) -> bool {
                *self == EM0R::PWM2
            }
            #[doc = "Checks if the value of the field is `PWM3`"]
            #[inline]
            pub fn is_pwm3(&self) -> bool {
                *self == EM0R::PWM3
            }
            #[doc = "Checks if the value of the field is `NEVER`"]
            #[inline]
            pub fn is_never(&self) -> bool {
                *self == EM0R::NEVER
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == EM0R::ALWAYS
            }
        }
        #[doc = "Possible values of the field `EM1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EM1R {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EM1R::PROCESSOR => 0,
                    EM1R::COMP0 => 0x01,
                    EM1R::COMP1 => 0x02,
                    EM1R::COMP2 => 0x03,
                    EM1R::EXTERNAL => 0x04,
                    EM1R::TIMER => 0x05,
                    EM1R::PWM0 => 0x06,
                    EM1R::PWM1 => 0x07,
                    EM1R::PWM2 => 0x08,
                    EM1R::PWM3 => 0x09,
                    EM1R::NEVER => 0x0e,
                    EM1R::ALWAYS => 0x0f,
                    EM1R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EM1R {
                match value {
                    0 => EM1R::PROCESSOR,
                    1 => EM1R::COMP0,
                    2 => EM1R::COMP1,
                    3 => EM1R::COMP2,
                    4 => EM1R::EXTERNAL,
                    5 => EM1R::TIMER,
                    6 => EM1R::PWM0,
                    7 => EM1R::PWM1,
                    8 => EM1R::PWM2,
                    9 => EM1R::PWM3,
                    14 => EM1R::NEVER,
                    15 => EM1R::ALWAYS,
                    i => EM1R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PROCESSOR`"]
            #[inline]
            pub fn is_processor(&self) -> bool {
                *self == EM1R::PROCESSOR
            }
            #[doc = "Checks if the value of the field is `COMP0`"]
            #[inline]
            pub fn is_comp0(&self) -> bool {
                *self == EM1R::COMP0
            }
            #[doc = "Checks if the value of the field is `COMP1`"]
            #[inline]
            pub fn is_comp1(&self) -> bool {
                *self == EM1R::COMP1
            }
            #[doc = "Checks if the value of the field is `COMP2`"]
            #[inline]
            pub fn is_comp2(&self) -> bool {
                *self == EM1R::COMP2
            }
            #[doc = "Checks if the value of the field is `EXTERNAL`"]
            #[inline]
            pub fn is_external(&self) -> bool {
                *self == EM1R::EXTERNAL
            }
            #[doc = "Checks if the value of the field is `TIMER`"]
            #[inline]
            pub fn is_timer(&self) -> bool {
                *self == EM1R::TIMER
            }
            #[doc = "Checks if the value of the field is `PWM0`"]
            #[inline]
            pub fn is_pwm0(&self) -> bool {
                *self == EM1R::PWM0
            }
            #[doc = "Checks if the value of the field is `PWM1`"]
            #[inline]
            pub fn is_pwm1(&self) -> bool {
                *self == EM1R::PWM1
            }
            #[doc = "Checks if the value of the field is `PWM2`"]
            #[inline]
            pub fn is_pwm2(&self) -> bool {
                *self == EM1R::PWM2
            }
            #[doc = "Checks if the value of the field is `PWM3`"]
            #[inline]
            pub fn is_pwm3(&self) -> bool {
                *self == EM1R::PWM3
            }
            #[doc = "Checks if the value of the field is `NEVER`"]
            #[inline]
            pub fn is_never(&self) -> bool {
                *self == EM1R::NEVER
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == EM1R::ALWAYS
            }
        }
        #[doc = "Possible values of the field `EM2`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EM2R {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EM2R::PROCESSOR => 0,
                    EM2R::COMP0 => 0x01,
                    EM2R::COMP1 => 0x02,
                    EM2R::COMP2 => 0x03,
                    EM2R::EXTERNAL => 0x04,
                    EM2R::TIMER => 0x05,
                    EM2R::PWM0 => 0x06,
                    EM2R::PWM1 => 0x07,
                    EM2R::PWM2 => 0x08,
                    EM2R::PWM3 => 0x09,
                    EM2R::NEVER => 0x0e,
                    EM2R::ALWAYS => 0x0f,
                    EM2R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EM2R {
                match value {
                    0 => EM2R::PROCESSOR,
                    1 => EM2R::COMP0,
                    2 => EM2R::COMP1,
                    3 => EM2R::COMP2,
                    4 => EM2R::EXTERNAL,
                    5 => EM2R::TIMER,
                    6 => EM2R::PWM0,
                    7 => EM2R::PWM1,
                    8 => EM2R::PWM2,
                    9 => EM2R::PWM3,
                    14 => EM2R::NEVER,
                    15 => EM2R::ALWAYS,
                    i => EM2R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PROCESSOR`"]
            #[inline]
            pub fn is_processor(&self) -> bool {
                *self == EM2R::PROCESSOR
            }
            #[doc = "Checks if the value of the field is `COMP0`"]
            #[inline]
            pub fn is_comp0(&self) -> bool {
                *self == EM2R::COMP0
            }
            #[doc = "Checks if the value of the field is `COMP1`"]
            #[inline]
            pub fn is_comp1(&self) -> bool {
                *self == EM2R::COMP1
            }
            #[doc = "Checks if the value of the field is `COMP2`"]
            #[inline]
            pub fn is_comp2(&self) -> bool {
                *self == EM2R::COMP2
            }
            #[doc = "Checks if the value of the field is `EXTERNAL`"]
            #[inline]
            pub fn is_external(&self) -> bool {
                *self == EM2R::EXTERNAL
            }
            #[doc = "Checks if the value of the field is `TIMER`"]
            #[inline]
            pub fn is_timer(&self) -> bool {
                *self == EM2R::TIMER
            }
            #[doc = "Checks if the value of the field is `PWM0`"]
            #[inline]
            pub fn is_pwm0(&self) -> bool {
                *self == EM2R::PWM0
            }
            #[doc = "Checks if the value of the field is `PWM1`"]
            #[inline]
            pub fn is_pwm1(&self) -> bool {
                *self == EM2R::PWM1
            }
            #[doc = "Checks if the value of the field is `PWM2`"]
            #[inline]
            pub fn is_pwm2(&self) -> bool {
                *self == EM2R::PWM2
            }
            #[doc = "Checks if the value of the field is `PWM3`"]
            #[inline]
            pub fn is_pwm3(&self) -> bool {
                *self == EM2R::PWM3
            }
            #[doc = "Checks if the value of the field is `NEVER`"]
            #[inline]
            pub fn is_never(&self) -> bool {
                *self == EM2R::NEVER
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == EM2R::ALWAYS
            }
        }
        #[doc = "Possible values of the field `EM3`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EM3R {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EM3R::PROCESSOR => 0,
                    EM3R::COMP0 => 0x01,
                    EM3R::COMP1 => 0x02,
                    EM3R::COMP2 => 0x03,
                    EM3R::EXTERNAL => 0x04,
                    EM3R::TIMER => 0x05,
                    EM3R::PWM0 => 0x06,
                    EM3R::PWM1 => 0x07,
                    EM3R::PWM2 => 0x08,
                    EM3R::PWM3 => 0x09,
                    EM3R::NEVER => 0x0e,
                    EM3R::ALWAYS => 0x0f,
                    EM3R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EM3R {
                match value {
                    0 => EM3R::PROCESSOR,
                    1 => EM3R::COMP0,
                    2 => EM3R::COMP1,
                    3 => EM3R::COMP2,
                    4 => EM3R::EXTERNAL,
                    5 => EM3R::TIMER,
                    6 => EM3R::PWM0,
                    7 => EM3R::PWM1,
                    8 => EM3R::PWM2,
                    9 => EM3R::PWM3,
                    14 => EM3R::NEVER,
                    15 => EM3R::ALWAYS,
                    i => EM3R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PROCESSOR`"]
            #[inline]
            pub fn is_processor(&self) -> bool {
                *self == EM3R::PROCESSOR
            }
            #[doc = "Checks if the value of the field is `COMP0`"]
            #[inline]
            pub fn is_comp0(&self) -> bool {
                *self == EM3R::COMP0
            }
            #[doc = "Checks if the value of the field is `COMP1`"]
            #[inline]
            pub fn is_comp1(&self) -> bool {
                *self == EM3R::COMP1
            }
            #[doc = "Checks if the value of the field is `COMP2`"]
            #[inline]
            pub fn is_comp2(&self) -> bool {
                *self == EM3R::COMP2
            }
            #[doc = "Checks if the value of the field is `EXTERNAL`"]
            #[inline]
            pub fn is_external(&self) -> bool {
                *self == EM3R::EXTERNAL
            }
            #[doc = "Checks if the value of the field is `TIMER`"]
            #[inline]
            pub fn is_timer(&self) -> bool {
                *self == EM3R::TIMER
            }
            #[doc = "Checks if the value of the field is `PWM0`"]
            #[inline]
            pub fn is_pwm0(&self) -> bool {
                *self == EM3R::PWM0
            }
            #[doc = "Checks if the value of the field is `PWM1`"]
            #[inline]
            pub fn is_pwm1(&self) -> bool {
                *self == EM3R::PWM1
            }
            #[doc = "Checks if the value of the field is `PWM2`"]
            #[inline]
            pub fn is_pwm2(&self) -> bool {
                *self == EM3R::PWM2
            }
            #[doc = "Checks if the value of the field is `PWM3`"]
            #[inline]
            pub fn is_pwm3(&self) -> bool {
                *self == EM3R::PWM3
            }
            #[doc = "Checks if the value of the field is `NEVER`"]
            #[inline]
            pub fn is_never(&self) -> bool {
                *self == EM3R::NEVER
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == EM3R::ALWAYS
            }
        }
        #[doc = "Values that can be written to the field `EM0`"]
        pub enum EM0W {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
        }
        impl EM0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EM0W::PROCESSOR => 0,
                    EM0W::COMP0 => 1,
                    EM0W::COMP1 => 2,
                    EM0W::COMP2 => 3,
                    EM0W::EXTERNAL => 4,
                    EM0W::TIMER => 5,
                    EM0W::PWM0 => 6,
                    EM0W::PWM1 => 7,
                    EM0W::PWM2 => 8,
                    EM0W::PWM3 => 9,
                    EM0W::NEVER => 14,
                    EM0W::ALWAYS => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EM0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EM0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EM0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Processor (default)"]
            #[inline]
            pub fn processor(self) -> &'a mut W {
                self.variant(EM0W::PROCESSOR)
            }
            #[doc = "Analog Comparator 0"]
            #[inline]
            pub fn comp0(self) -> &'a mut W {
                self.variant(EM0W::COMP0)
            }
            #[doc = "Analog Comparator 1"]
            #[inline]
            pub fn comp1(self) -> &'a mut W {
                self.variant(EM0W::COMP1)
            }
            #[doc = "Analog Comparator 2"]
            #[inline]
            pub fn comp2(self) -> &'a mut W {
                self.variant(EM0W::COMP2)
            }
            #[doc = "External (GPIO Pins)"]
            #[inline]
            pub fn external(self) -> &'a mut W {
                self.variant(EM0W::EXTERNAL)
            }
            #[doc = "Timer"]
            #[inline]
            pub fn timer(self) -> &'a mut W {
                self.variant(EM0W::TIMER)
            }
            #[doc = "PWM generator 0"]
            #[inline]
            pub fn pwm0(self) -> &'a mut W {
                self.variant(EM0W::PWM0)
            }
            #[doc = "PWM generator 1"]
            #[inline]
            pub fn pwm1(self) -> &'a mut W {
                self.variant(EM0W::PWM1)
            }
            #[doc = "PWM generator 2"]
            #[inline]
            pub fn pwm2(self) -> &'a mut W {
                self.variant(EM0W::PWM2)
            }
            #[doc = "PWM generator 3"]
            #[inline]
            pub fn pwm3(self) -> &'a mut W {
                self.variant(EM0W::PWM3)
            }
            #[doc = "Never Trigger"]
            #[inline]
            pub fn never(self) -> &'a mut W {
                self.variant(EM0W::NEVER)
            }
            #[doc = "Always (continuously sample)"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(EM0W::ALWAYS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EM1`"]
        pub enum EM1W {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
        }
        impl EM1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EM1W::PROCESSOR => 0,
                    EM1W::COMP0 => 1,
                    EM1W::COMP1 => 2,
                    EM1W::COMP2 => 3,
                    EM1W::EXTERNAL => 4,
                    EM1W::TIMER => 5,
                    EM1W::PWM0 => 6,
                    EM1W::PWM1 => 7,
                    EM1W::PWM2 => 8,
                    EM1W::PWM3 => 9,
                    EM1W::NEVER => 14,
                    EM1W::ALWAYS => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EM1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EM1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EM1W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Processor (default)"]
            #[inline]
            pub fn processor(self) -> &'a mut W {
                self.variant(EM1W::PROCESSOR)
            }
            #[doc = "Analog Comparator 0"]
            #[inline]
            pub fn comp0(self) -> &'a mut W {
                self.variant(EM1W::COMP0)
            }
            #[doc = "Analog Comparator 1"]
            #[inline]
            pub fn comp1(self) -> &'a mut W {
                self.variant(EM1W::COMP1)
            }
            #[doc = "Analog Comparator 2"]
            #[inline]
            pub fn comp2(self) -> &'a mut W {
                self.variant(EM1W::COMP2)
            }
            #[doc = "External (GPIO Pins)"]
            #[inline]
            pub fn external(self) -> &'a mut W {
                self.variant(EM1W::EXTERNAL)
            }
            #[doc = "Timer"]
            #[inline]
            pub fn timer(self) -> &'a mut W {
                self.variant(EM1W::TIMER)
            }
            #[doc = "PWM generator 0"]
            #[inline]
            pub fn pwm0(self) -> &'a mut W {
                self.variant(EM1W::PWM0)
            }
            #[doc = "PWM generator 1"]
            #[inline]
            pub fn pwm1(self) -> &'a mut W {
                self.variant(EM1W::PWM1)
            }
            #[doc = "PWM generator 2"]
            #[inline]
            pub fn pwm2(self) -> &'a mut W {
                self.variant(EM1W::PWM2)
            }
            #[doc = "PWM generator 3"]
            #[inline]
            pub fn pwm3(self) -> &'a mut W {
                self.variant(EM1W::PWM3)
            }
            #[doc = "Never Trigger"]
            #[inline]
            pub fn never(self) -> &'a mut W {
                self.variant(EM1W::NEVER)
            }
            #[doc = "Always (continuously sample)"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(EM1W::ALWAYS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EM2`"]
        pub enum EM2W {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
        }
        impl EM2W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EM2W::PROCESSOR => 0,
                    EM2W::COMP0 => 1,
                    EM2W::COMP1 => 2,
                    EM2W::COMP2 => 3,
                    EM2W::EXTERNAL => 4,
                    EM2W::TIMER => 5,
                    EM2W::PWM0 => 6,
                    EM2W::PWM1 => 7,
                    EM2W::PWM2 => 8,
                    EM2W::PWM3 => 9,
                    EM2W::NEVER => 14,
                    EM2W::ALWAYS => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EM2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EM2W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EM2W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Processor (default)"]
            #[inline]
            pub fn processor(self) -> &'a mut W {
                self.variant(EM2W::PROCESSOR)
            }
            #[doc = "Analog Comparator 0"]
            #[inline]
            pub fn comp0(self) -> &'a mut W {
                self.variant(EM2W::COMP0)
            }
            #[doc = "Analog Comparator 1"]
            #[inline]
            pub fn comp1(self) -> &'a mut W {
                self.variant(EM2W::COMP1)
            }
            #[doc = "Analog Comparator 2"]
            #[inline]
            pub fn comp2(self) -> &'a mut W {
                self.variant(EM2W::COMP2)
            }
            #[doc = "External (GPIO Pins)"]
            #[inline]
            pub fn external(self) -> &'a mut W {
                self.variant(EM2W::EXTERNAL)
            }
            #[doc = "Timer"]
            #[inline]
            pub fn timer(self) -> &'a mut W {
                self.variant(EM2W::TIMER)
            }
            #[doc = "PWM generator 0"]
            #[inline]
            pub fn pwm0(self) -> &'a mut W {
                self.variant(EM2W::PWM0)
            }
            #[doc = "PWM generator 1"]
            #[inline]
            pub fn pwm1(self) -> &'a mut W {
                self.variant(EM2W::PWM1)
            }
            #[doc = "PWM generator 2"]
            #[inline]
            pub fn pwm2(self) -> &'a mut W {
                self.variant(EM2W::PWM2)
            }
            #[doc = "PWM generator 3"]
            #[inline]
            pub fn pwm3(self) -> &'a mut W {
                self.variant(EM2W::PWM3)
            }
            #[doc = "Never Trigger"]
            #[inline]
            pub fn never(self) -> &'a mut W {
                self.variant(EM2W::NEVER)
            }
            #[doc = "Always (continuously sample)"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(EM2W::ALWAYS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EM3`"]
        pub enum EM3W {
            #[doc = "Processor (default)"]
            PROCESSOR,
            #[doc = "Analog Comparator 0"]
            COMP0,
            #[doc = "Analog Comparator 1"]
            COMP1,
            #[doc = "Analog Comparator 2"]
            COMP2,
            #[doc = "External (GPIO Pins)"]
            EXTERNAL,
            #[doc = "Timer"]
            TIMER,
            #[doc = "PWM generator 0"]
            PWM0,
            #[doc = "PWM generator 1"]
            PWM1,
            #[doc = "PWM generator 2"]
            PWM2,
            #[doc = "PWM generator 3"]
            PWM3,
            #[doc = "Never Trigger"]
            NEVER,
            #[doc = "Always (continuously sample)"]
            ALWAYS,
        }
        impl EM3W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EM3W::PROCESSOR => 0,
                    EM3W::COMP0 => 1,
                    EM3W::COMP1 => 2,
                    EM3W::COMP2 => 3,
                    EM3W::EXTERNAL => 4,
                    EM3W::TIMER => 5,
                    EM3W::PWM0 => 6,
                    EM3W::PWM1 => 7,
                    EM3W::PWM2 => 8,
                    EM3W::PWM3 => 9,
                    EM3W::NEVER => 14,
                    EM3W::ALWAYS => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EM3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EM3W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EM3W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Processor (default)"]
            #[inline]
            pub fn processor(self) -> &'a mut W {
                self.variant(EM3W::PROCESSOR)
            }
            #[doc = "Analog Comparator 0"]
            #[inline]
            pub fn comp0(self) -> &'a mut W {
                self.variant(EM3W::COMP0)
            }
            #[doc = "Analog Comparator 1"]
            #[inline]
            pub fn comp1(self) -> &'a mut W {
                self.variant(EM3W::COMP1)
            }
            #[doc = "Analog Comparator 2"]
            #[inline]
            pub fn comp2(self) -> &'a mut W {
                self.variant(EM3W::COMP2)
            }
            #[doc = "External (GPIO Pins)"]
            #[inline]
            pub fn external(self) -> &'a mut W {
                self.variant(EM3W::EXTERNAL)
            }
            #[doc = "Timer"]
            #[inline]
            pub fn timer(self) -> &'a mut W {
                self.variant(EM3W::TIMER)
            }
            #[doc = "PWM generator 0"]
            #[inline]
            pub fn pwm0(self) -> &'a mut W {
                self.variant(EM3W::PWM0)
            }
            #[doc = "PWM generator 1"]
            #[inline]
            pub fn pwm1(self) -> &'a mut W {
                self.variant(EM3W::PWM1)
            }
            #[doc = "PWM generator 2"]
            #[inline]
            pub fn pwm2(self) -> &'a mut W {
                self.variant(EM3W::PWM2)
            }
            #[doc = "PWM generator 3"]
            #[inline]
            pub fn pwm3(self) -> &'a mut W {
                self.variant(EM3W::PWM3)
            }
            #[doc = "Never Trigger"]
            #[inline]
            pub fn never(self) -> &'a mut W {
                self.variant(EM3W::NEVER)
            }
            #[doc = "Always (continuously sample)"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(EM3W::ALWAYS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - SS0 Trigger Select"]
            #[inline]
            pub fn em0(&self) -> EM0R {
                EM0R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:7 - SS1 Trigger Select"]
            #[inline]
            pub fn em1(&self) -> EM1R {
                EM1R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:11 - SS2 Trigger Select"]
            #[inline]
            pub fn em2(&self) -> EM2R {
                EM2R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:15 - SS3 Trigger Select"]
            #[inline]
            pub fn em3(&self) -> EM3R {
                EM3R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - SS0 Trigger Select"]
            #[inline]
            pub fn em0(&mut self) -> _EM0W {
                _EM0W { w: self }
            }
            #[doc = "Bits 4:7 - SS1 Trigger Select"]
            #[inline]
            pub fn em1(&mut self) -> _EM1W {
                _EM1W { w: self }
            }
            #[doc = "Bits 8:11 - SS2 Trigger Select"]
            #[inline]
            pub fn em2(&mut self) -> _EM2W {
                _EM2W { w: self }
            }
            #[doc = "Bits 12:15 - SS3 Trigger Select"]
            #[inline]
            pub fn em3(&mut self) -> _EM3W {
                _EM3W { w: self }
            }
        }
    }
    #[doc = "ADC Underflow Status"]
    pub struct USTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Underflow Status"]
    pub mod ustat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USTAT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct UV0R {
            bits: bool,
        }
        impl UV0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UV1R {
            bits: bool,
        }
        impl UV1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UV2R {
            bits: bool,
        }
        impl UV2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UV3R {
            bits: bool,
        }
        impl UV3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _UV0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _UV0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _UV1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _UV1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UV2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _UV2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UV3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _UV3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 FIFO Underflow"]
            #[inline]
            pub fn uv0(&self) -> UV0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UV0R { bits }
            }
            #[doc = "Bit 1 - SS1 FIFO Underflow"]
            #[inline]
            pub fn uv1(&self) -> UV1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UV1R { bits }
            }
            #[doc = "Bit 2 - SS2 FIFO Underflow"]
            #[inline]
            pub fn uv2(&self) -> UV2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UV2R { bits }
            }
            #[doc = "Bit 3 - SS3 FIFO Underflow"]
            #[inline]
            pub fn uv3(&self) -> UV3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UV3R { bits }
            }
        }
        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 = "Bit 0 - SS0 FIFO Underflow"]
            #[inline]
            pub fn uv0(&mut self) -> _UV0W {
                _UV0W { w: self }
            }
            #[doc = "Bit 1 - SS1 FIFO Underflow"]
            #[inline]
            pub fn uv1(&mut self) -> _UV1W {
                _UV1W { w: self }
            }
            #[doc = "Bit 2 - SS2 FIFO Underflow"]
            #[inline]
            pub fn uv2(&mut self) -> _UV2W {
                _UV2W { w: self }
            }
            #[doc = "Bit 3 - SS3 FIFO Underflow"]
            #[inline]
            pub fn uv3(&mut self) -> _UV3W {
                _UV3W { w: self }
            }
        }
    }
    #[doc = "ADC Trigger Source Select"]
    pub struct TSSEL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Trigger Source Select"]
    pub mod tssel {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TSSEL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PS0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PS0R {
            #[doc = "Use Generator 0 (and its trigger) in PWM module 0"]
            _0,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PS0R::_0 => 0,
                    PS0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PS0R {
                match value {
                    0 => PS0R::_0,
                    i => PS0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PS0R::_0
            }
        }
        #[doc = "Possible values of the field `PS1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PS1R {
            #[doc = "Use Generator 1 (and its trigger) in PWM module 0"]
            _0,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PS1R::_0 => 0,
                    PS1R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PS1R {
                match value {
                    0 => PS1R::_0,
                    i => PS1R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PS1R::_0
            }
        }
        #[doc = "Possible values of the field `PS2`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PS2R {
            #[doc = "Use Generator 2 (and its trigger) in PWM module 0"]
            _0,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PS2R::_0 => 0,
                    PS2R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PS2R {
                match value {
                    0 => PS2R::_0,
                    i => PS2R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PS2R::_0
            }
        }
        #[doc = "Possible values of the field `PS3`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PS3R {
            #[doc = "Use Generator 3 (and its trigger) in PWM module 0"]
            _0,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PS3R::_0 => 0,
                    PS3R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PS3R {
                match value {
                    0 => PS3R::_0,
                    i => PS3R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PS3R::_0
            }
        }
        #[doc = "Values that can be written to the field `PS0`"]
        pub enum PS0W {
            #[doc = "Use Generator 0 (and its trigger) in PWM module 0"]
            _0,
        }
        impl PS0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PS0W::_0 => 0,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PS0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PS0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use Generator 0 (and its trigger) in PWM module 0"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PS0W::_0)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PS1`"]
        pub enum PS1W {
            #[doc = "Use Generator 1 (and its trigger) in PWM module 0"]
            _0,
        }
        impl PS1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PS1W::_0 => 0,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PS1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PS1W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use Generator 1 (and its trigger) in PWM module 0"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PS1W::_0)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PS2`"]
        pub enum PS2W {
            #[doc = "Use Generator 2 (and its trigger) in PWM module 0"]
            _0,
        }
        impl PS2W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PS2W::_0 => 0,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PS2W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PS2W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use Generator 2 (and its trigger) in PWM module 0"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PS2W::_0)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PS3`"]
        pub enum PS3W {
            #[doc = "Use Generator 3 (and its trigger) in PWM module 0"]
            _0,
        }
        impl PS3W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PS3W::_0 => 0,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PS3W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PS3W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use Generator 3 (and its trigger) in PWM module 0"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PS3W::_0)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 4:5 - Generator 0 PWM Module Trigger Select"]
            #[inline]
            pub fn ps0(&self) -> PS0R {
                PS0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - Generator 1 PWM Module Trigger Select"]
            #[inline]
            pub fn ps1(&self) -> PS1R {
                PS1R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 20:21 - Generator 2 PWM Module Trigger Select"]
            #[inline]
            pub fn ps2(&self) -> PS2R {
                PS2R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 28:29 - Generator 3 PWM Module Trigger Select"]
            #[inline]
            pub fn ps3(&self) -> PS3R {
                PS3R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 4:5 - Generator 0 PWM Module Trigger Select"]
            #[inline]
            pub fn ps0(&mut self) -> _PS0W {
                _PS0W { w: self }
            }
            #[doc = "Bits 12:13 - Generator 1 PWM Module Trigger Select"]
            #[inline]
            pub fn ps1(&mut self) -> _PS1W {
                _PS1W { w: self }
            }
            #[doc = "Bits 20:21 - Generator 2 PWM Module Trigger Select"]
            #[inline]
            pub fn ps2(&mut self) -> _PS2W {
                _PS2W { w: self }
            }
            #[doc = "Bits 28:29 - Generator 3 PWM Module Trigger Select"]
            #[inline]
            pub fn ps3(&mut self) -> _PS3W {
                _PS3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequencer Priority"]
    pub struct SSPRI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequencer Priority"]
    pub mod sspri {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSPRI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS0R {
            bits: u8,
        }
        impl SS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS1R {
            bits: u8,
        }
        impl SS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS2R {
            bits: u8,
        }
        impl SS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS3R {
            bits: u8,
        }
        impl SS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _SS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - SS0 Priority"]
            #[inline]
            pub fn ss0(&self) -> SS0R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SS0R { bits }
            }
            #[doc = "Bits 4:5 - SS1 Priority"]
            #[inline]
            pub fn ss1(&self) -> SS1R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SS1R { bits }
            }
            #[doc = "Bits 8:9 - SS2 Priority"]
            #[inline]
            pub fn ss2(&self) -> SS2R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SS2R { bits }
            }
            #[doc = "Bits 12:13 - SS3 Priority"]
            #[inline]
            pub fn ss3(&self) -> SS3R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SS3R { bits }
            }
        }
        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 0:1 - SS0 Priority"]
            #[inline]
            pub fn ss0(&mut self) -> _SS0W {
                _SS0W { w: self }
            }
            #[doc = "Bits 4:5 - SS1 Priority"]
            #[inline]
            pub fn ss1(&mut self) -> _SS1W {
                _SS1W { w: self }
            }
            #[doc = "Bits 8:9 - SS2 Priority"]
            #[inline]
            pub fn ss2(&mut self) -> _SS2W {
                _SS2W { w: self }
            }
            #[doc = "Bits 12:13 - SS3 Priority"]
            #[inline]
            pub fn ss3(&mut self) -> _SS3W {
                _SS3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Phase Control"]
    pub struct SPC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Phase Control"]
    pub mod spc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SPC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PHASE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PHASER {
            #[doc = "ADC sample lags by 0.0"]
            _0,
            #[doc = "ADC sample lags by 22.5"]
            _22_5,
            #[doc = "ADC sample lags by 45.0"]
            _45,
            #[doc = "ADC sample lags by 67.5"]
            _67_5,
            #[doc = "ADC sample lags by 90.0"]
            _90,
            #[doc = "ADC sample lags by 112.5"]
            _112_5,
            #[doc = "ADC sample lags by 135.0"]
            _135,
            #[doc = "ADC sample lags by 157.5"]
            _157_5,
            #[doc = "ADC sample lags by 180.0"]
            _180,
            #[doc = "ADC sample lags by 202.5"]
            _202_5,
            #[doc = "ADC sample lags by 225.0"]
            _225,
            #[doc = "ADC sample lags by 247.5"]
            _247_5,
            #[doc = "ADC sample lags by 270.0"]
            _270,
            #[doc = "ADC sample lags by 292.5"]
            _292_5,
            #[doc = "ADC sample lags by 315.0"]
            _315,
            #[doc = "ADC sample lags by 337.5"]
            _337_5,
        }
        impl PHASER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PHASER::_0 => 0,
                    PHASER::_22_5 => 0x01,
                    PHASER::_45 => 0x02,
                    PHASER::_67_5 => 0x03,
                    PHASER::_90 => 0x04,
                    PHASER::_112_5 => 0x05,
                    PHASER::_135 => 0x06,
                    PHASER::_157_5 => 0x07,
                    PHASER::_180 => 0x08,
                    PHASER::_202_5 => 0x09,
                    PHASER::_225 => 0x0a,
                    PHASER::_247_5 => 0x0b,
                    PHASER::_270 => 0x0c,
                    PHASER::_292_5 => 0x0d,
                    PHASER::_315 => 0x0e,
                    PHASER::_337_5 => 0x0f,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PHASER {
                match value {
                    0 => PHASER::_0,
                    1 => PHASER::_22_5,
                    2 => PHASER::_45,
                    3 => PHASER::_67_5,
                    4 => PHASER::_90,
                    5 => PHASER::_112_5,
                    6 => PHASER::_135,
                    7 => PHASER::_157_5,
                    8 => PHASER::_180,
                    9 => PHASER::_202_5,
                    10 => PHASER::_225,
                    11 => PHASER::_247_5,
                    12 => PHASER::_270,
                    13 => PHASER::_292_5,
                    14 => PHASER::_315,
                    15 => PHASER::_337_5,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PHASER::_0
            }
            #[doc = "Checks if the value of the field is `_22_5`"]
            #[inline]
            pub fn is_22_5(&self) -> bool {
                *self == PHASER::_22_5
            }
            #[doc = "Checks if the value of the field is `_45`"]
            #[inline]
            pub fn is_45(&self) -> bool {
                *self == PHASER::_45
            }
            #[doc = "Checks if the value of the field is `_67_5`"]
            #[inline]
            pub fn is_67_5(&self) -> bool {
                *self == PHASER::_67_5
            }
            #[doc = "Checks if the value of the field is `_90`"]
            #[inline]
            pub fn is_90(&self) -> bool {
                *self == PHASER::_90
            }
            #[doc = "Checks if the value of the field is `_112_5`"]
            #[inline]
            pub fn is_112_5(&self) -> bool {
                *self == PHASER::_112_5
            }
            #[doc = "Checks if the value of the field is `_135`"]
            #[inline]
            pub fn is_135(&self) -> bool {
                *self == PHASER::_135
            }
            #[doc = "Checks if the value of the field is `_157_5`"]
            #[inline]
            pub fn is_157_5(&self) -> bool {
                *self == PHASER::_157_5
            }
            #[doc = "Checks if the value of the field is `_180`"]
            #[inline]
            pub fn is_180(&self) -> bool {
                *self == PHASER::_180
            }
            #[doc = "Checks if the value of the field is `_202_5`"]
            #[inline]
            pub fn is_202_5(&self) -> bool {
                *self == PHASER::_202_5
            }
            #[doc = "Checks if the value of the field is `_225`"]
            #[inline]
            pub fn is_225(&self) -> bool {
                *self == PHASER::_225
            }
            #[doc = "Checks if the value of the field is `_247_5`"]
            #[inline]
            pub fn is_247_5(&self) -> bool {
                *self == PHASER::_247_5
            }
            #[doc = "Checks if the value of the field is `_270`"]
            #[inline]
            pub fn is_270(&self) -> bool {
                *self == PHASER::_270
            }
            #[doc = "Checks if the value of the field is `_292_5`"]
            #[inline]
            pub fn is_292_5(&self) -> bool {
                *self == PHASER::_292_5
            }
            #[doc = "Checks if the value of the field is `_315`"]
            #[inline]
            pub fn is_315(&self) -> bool {
                *self == PHASER::_315
            }
            #[doc = "Checks if the value of the field is `_337_5`"]
            #[inline]
            pub fn is_337_5(&self) -> bool {
                *self == PHASER::_337_5
            }
        }
        #[doc = "Values that can be written to the field `PHASE`"]
        pub enum PHASEW {
            #[doc = "ADC sample lags by 0.0"]
            _0,
            #[doc = "ADC sample lags by 22.5"]
            _22_5,
            #[doc = "ADC sample lags by 45.0"]
            _45,
            #[doc = "ADC sample lags by 67.5"]
            _67_5,
            #[doc = "ADC sample lags by 90.0"]
            _90,
            #[doc = "ADC sample lags by 112.5"]
            _112_5,
            #[doc = "ADC sample lags by 135.0"]
            _135,
            #[doc = "ADC sample lags by 157.5"]
            _157_5,
            #[doc = "ADC sample lags by 180.0"]
            _180,
            #[doc = "ADC sample lags by 202.5"]
            _202_5,
            #[doc = "ADC sample lags by 225.0"]
            _225,
            #[doc = "ADC sample lags by 247.5"]
            _247_5,
            #[doc = "ADC sample lags by 270.0"]
            _270,
            #[doc = "ADC sample lags by 292.5"]
            _292_5,
            #[doc = "ADC sample lags by 315.0"]
            _315,
            #[doc = "ADC sample lags by 337.5"]
            _337_5,
        }
        impl PHASEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PHASEW::_0 => 0,
                    PHASEW::_22_5 => 1,
                    PHASEW::_45 => 2,
                    PHASEW::_67_5 => 3,
                    PHASEW::_90 => 4,
                    PHASEW::_112_5 => 5,
                    PHASEW::_135 => 6,
                    PHASEW::_157_5 => 7,
                    PHASEW::_180 => 8,
                    PHASEW::_202_5 => 9,
                    PHASEW::_225 => 10,
                    PHASEW::_247_5 => 11,
                    PHASEW::_270 => 12,
                    PHASEW::_292_5 => 13,
                    PHASEW::_315 => 14,
                    PHASEW::_337_5 => 15,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PHASEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PHASEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PHASEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "ADC sample lags by 0.0"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PHASEW::_0)
            }
            #[doc = "ADC sample lags by 22.5"]
            #[inline]
            pub fn _22_5(self) -> &'a mut W {
                self.variant(PHASEW::_22_5)
            }
            #[doc = "ADC sample lags by 45.0"]
            #[inline]
            pub fn _45(self) -> &'a mut W {
                self.variant(PHASEW::_45)
            }
            #[doc = "ADC sample lags by 67.5"]
            #[inline]
            pub fn _67_5(self) -> &'a mut W {
                self.variant(PHASEW::_67_5)
            }
            #[doc = "ADC sample lags by 90.0"]
            #[inline]
            pub fn _90(self) -> &'a mut W {
                self.variant(PHASEW::_90)
            }
            #[doc = "ADC sample lags by 112.5"]
            #[inline]
            pub fn _112_5(self) -> &'a mut W {
                self.variant(PHASEW::_112_5)
            }
            #[doc = "ADC sample lags by 135.0"]
            #[inline]
            pub fn _135(self) -> &'a mut W {
                self.variant(PHASEW::_135)
            }
            #[doc = "ADC sample lags by 157.5"]
            #[inline]
            pub fn _157_5(self) -> &'a mut W {
                self.variant(PHASEW::_157_5)
            }
            #[doc = "ADC sample lags by 180.0"]
            #[inline]
            pub fn _180(self) -> &'a mut W {
                self.variant(PHASEW::_180)
            }
            #[doc = "ADC sample lags by 202.5"]
            #[inline]
            pub fn _202_5(self) -> &'a mut W {
                self.variant(PHASEW::_202_5)
            }
            #[doc = "ADC sample lags by 225.0"]
            #[inline]
            pub fn _225(self) -> &'a mut W {
                self.variant(PHASEW::_225)
            }
            #[doc = "ADC sample lags by 247.5"]
            #[inline]
            pub fn _247_5(self) -> &'a mut W {
                self.variant(PHASEW::_247_5)
            }
            #[doc = "ADC sample lags by 270.0"]
            #[inline]
            pub fn _270(self) -> &'a mut W {
                self.variant(PHASEW::_270)
            }
            #[doc = "ADC sample lags by 292.5"]
            #[inline]
            pub fn _292_5(self) -> &'a mut W {
                self.variant(PHASEW::_292_5)
            }
            #[doc = "ADC sample lags by 315.0"]
            #[inline]
            pub fn _315(self) -> &'a mut W {
                self.variant(PHASEW::_315)
            }
            #[doc = "ADC sample lags by 337.5"]
            #[inline]
            pub fn _337_5(self) -> &'a mut W {
                self.variant(PHASEW::_337_5)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Phase Difference"]
            #[inline]
            pub fn phase(&self) -> PHASER {
                PHASER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - Phase Difference"]
            #[inline]
            pub fn phase(&mut self) -> _PHASEW {
                _PHASEW { w: self }
            }
        }
    }
    #[doc = "ADC Processor Sample Sequence Initiate"]
    pub struct PSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Processor Sample Sequence Initiate"]
    pub mod pssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS0R {
            bits: bool,
        }
        impl SS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS1R {
            bits: bool,
        }
        impl SS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS2R {
            bits: bool,
        }
        impl SS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SS3R {
            bits: bool,
        }
        impl SS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYNCWAITR {
            bits: bool,
        }
        impl SYNCWAITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GSYNCR {
            bits: bool,
        }
        impl GSYNCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _SS3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYNCWAITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYNCWAITW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GSYNCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GSYNCW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SS0 Initiate"]
            #[inline]
            pub fn ss0(&self) -> SS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SS0R { bits }
            }
            #[doc = "Bit 1 - SS1 Initiate"]
            #[inline]
            pub fn ss1(&self) -> SS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SS1R { bits }
            }
            #[doc = "Bit 2 - SS2 Initiate"]
            #[inline]
            pub fn ss2(&self) -> SS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SS2R { bits }
            }
            #[doc = "Bit 3 - SS3 Initiate"]
            #[inline]
            pub fn ss3(&self) -> SS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SS3R { bits }
            }
            #[doc = "Bit 27 - Synchronize Wait"]
            #[inline]
            pub fn syncwait(&self) -> SYNCWAITR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYNCWAITR { bits }
            }
            #[doc = "Bit 31 - Global Synchronize"]
            #[inline]
            pub fn gsync(&self) -> GSYNCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GSYNCR { bits }
            }
        }
        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 = "Bit 0 - SS0 Initiate"]
            #[inline]
            pub fn ss0(&mut self) -> _SS0W {
                _SS0W { w: self }
            }
            #[doc = "Bit 1 - SS1 Initiate"]
            #[inline]
            pub fn ss1(&mut self) -> _SS1W {
                _SS1W { w: self }
            }
            #[doc = "Bit 2 - SS2 Initiate"]
            #[inline]
            pub fn ss2(&mut self) -> _SS2W {
                _SS2W { w: self }
            }
            #[doc = "Bit 3 - SS3 Initiate"]
            #[inline]
            pub fn ss3(&mut self) -> _SS3W {
                _SS3W { w: self }
            }
            #[doc = "Bit 27 - Synchronize Wait"]
            #[inline]
            pub fn syncwait(&mut self) -> _SYNCWAITW {
                _SYNCWAITW { w: self }
            }
            #[doc = "Bit 31 - Global Synchronize"]
            #[inline]
            pub fn gsync(&mut self) -> _GSYNCW {
                _GSYNCW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Averaging Control"]
    pub struct SAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Averaging Control"]
    pub mod sac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `AVG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum AVGR {
            #[doc = "No hardware oversampling"]
            OFF,
            #[doc = "2x hardware oversampling"]
            _2X,
            #[doc = "4x hardware oversampling"]
            _4X,
            #[doc = "8x hardware oversampling"]
            _8X,
            #[doc = "16x hardware oversampling"]
            _16X,
            #[doc = "32x hardware oversampling"]
            _32X,
            #[doc = "64x hardware oversampling"]
            _64X,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl AVGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    AVGR::OFF => 0,
                    AVGR::_2X => 0x01,
                    AVGR::_4X => 0x02,
                    AVGR::_8X => 0x03,
                    AVGR::_16X => 0x04,
                    AVGR::_32X => 0x05,
                    AVGR::_64X => 0x06,
                    AVGR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> AVGR {
                match value {
                    0 => AVGR::OFF,
                    1 => AVGR::_2X,
                    2 => AVGR::_4X,
                    3 => AVGR::_8X,
                    4 => AVGR::_16X,
                    5 => AVGR::_32X,
                    6 => AVGR::_64X,
                    i => AVGR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == AVGR::OFF
            }
            #[doc = "Checks if the value of the field is `_2X`"]
            #[inline]
            pub fn is_2x(&self) -> bool {
                *self == AVGR::_2X
            }
            #[doc = "Checks if the value of the field is `_4X`"]
            #[inline]
            pub fn is_4x(&self) -> bool {
                *self == AVGR::_4X
            }
            #[doc = "Checks if the value of the field is `_8X`"]
            #[inline]
            pub fn is_8x(&self) -> bool {
                *self == AVGR::_8X
            }
            #[doc = "Checks if the value of the field is `_16X`"]
            #[inline]
            pub fn is_16x(&self) -> bool {
                *self == AVGR::_16X
            }
            #[doc = "Checks if the value of the field is `_32X`"]
            #[inline]
            pub fn is_32x(&self) -> bool {
                *self == AVGR::_32X
            }
            #[doc = "Checks if the value of the field is `_64X`"]
            #[inline]
            pub fn is_64x(&self) -> bool {
                *self == AVGR::_64X
            }
        }
        #[doc = "Values that can be written to the field `AVG`"]
        pub enum AVGW {
            #[doc = "No hardware oversampling"]
            OFF,
            #[doc = "2x hardware oversampling"]
            _2X,
            #[doc = "4x hardware oversampling"]
            _4X,
            #[doc = "8x hardware oversampling"]
            _8X,
            #[doc = "16x hardware oversampling"]
            _16X,
            #[doc = "32x hardware oversampling"]
            _32X,
            #[doc = "64x hardware oversampling"]
            _64X,
        }
        impl AVGW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    AVGW::OFF => 0,
                    AVGW::_2X => 1,
                    AVGW::_4X => 2,
                    AVGW::_8X => 3,
                    AVGW::_16X => 4,
                    AVGW::_32X => 5,
                    AVGW::_64X => 6,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _AVGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AVGW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: AVGW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "No hardware oversampling"]
            #[inline]
            pub fn off(self) -> &'a mut W {
                self.variant(AVGW::OFF)
            }
            #[doc = "2x hardware oversampling"]
            #[inline]
            pub fn _2x(self) -> &'a mut W {
                self.variant(AVGW::_2X)
            }
            #[doc = "4x hardware oversampling"]
            #[inline]
            pub fn _4x(self) -> &'a mut W {
                self.variant(AVGW::_4X)
            }
            #[doc = "8x hardware oversampling"]
            #[inline]
            pub fn _8x(self) -> &'a mut W {
                self.variant(AVGW::_8X)
            }
            #[doc = "16x hardware oversampling"]
            #[inline]
            pub fn _16x(self) -> &'a mut W {
                self.variant(AVGW::_16X)
            }
            #[doc = "32x hardware oversampling"]
            #[inline]
            pub fn _32x(self) -> &'a mut W {
                self.variant(AVGW::_32X)
            }
            #[doc = "64x hardware oversampling"]
            #[inline]
            pub fn _64x(self) -> &'a mut W {
                self.variant(AVGW::_64X)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Hardware Averaging Control"]
            #[inline]
            pub fn avg(&self) -> AVGR {
                AVGR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:2 - Hardware Averaging Control"]
            #[inline]
            pub fn avg(&mut self) -> _AVGW {
                _AVGW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Interrupt Status and Clear"]
    pub struct DCISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Interrupt Status and Clear"]
    pub mod dcisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT0R {
            bits: bool,
        }
        impl DCINT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT1R {
            bits: bool,
        }
        impl DCINT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT2R {
            bits: bool,
        }
        impl DCINT2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT3R {
            bits: bool,
        }
        impl DCINT3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT4R {
            bits: bool,
        }
        impl DCINT4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT5R {
            bits: bool,
        }
        impl DCINT5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT6R {
            bits: bool,
        }
        impl DCINT6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCINT7R {
            bits: bool,
        }
        impl DCINT7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Digital Comparator 0 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint0(&self) -> DCINT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT0R { bits }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint1(&self) -> DCINT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT1R { bits }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint2(&self) -> DCINT2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT2R { bits }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint3(&self) -> DCINT3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT3R { bits }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint4(&self) -> DCINT4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT4R { bits }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint5(&self) -> DCINT5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT5R { bits }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint6(&self) -> DCINT6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT6R { bits }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint7(&self) -> DCINT7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCINT7R { bits }
            }
        }
        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 = "Bit 0 - Digital Comparator 0 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint0(&mut self) -> _DCINT0W {
                _DCINT0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator 1 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint1(&mut self) -> _DCINT1W {
                _DCINT1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator 2 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint2(&mut self) -> _DCINT2W {
                _DCINT2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator 3 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint3(&mut self) -> _DCINT3W {
                _DCINT3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator 4 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint4(&mut self) -> _DCINT4W {
                _DCINT4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator 5 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint5(&mut self) -> _DCINT5W {
                _DCINT5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator 6 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint6(&mut self) -> _DCINT6W {
                _DCINT6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator 7 Interrupt Status and Clear"]
            #[inline]
            pub fn dcint7(&mut self) -> _DCINT7W {
                _DCINT7W { w: self }
            }
        }
    }
    #[doc = "ADC Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `VREF`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VREFR {
            #[doc = "VDDA and GNDA are the voltage references"]
            INTERNAL,
            #[doc = "The external VREFA+ and VREFA- inputs are the voltage references"]
            EXT_3V,
        }
        impl VREFR {
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                match *self {
                    VREFR::INTERNAL => false,
                    VREFR::EXT_3V => true,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: bool) -> VREFR {
                match value {
                    false => VREFR::INTERNAL,
                    true => VREFR::EXT_3V,
                }
            }
            #[doc = "Checks if the value of the field is `INTERNAL`"]
            #[inline]
            pub fn is_internal(&self) -> bool {
                *self == VREFR::INTERNAL
            }
            #[doc = "Checks if the value of the field is `EXT_3V`"]
            #[inline]
            pub fn is_ext_3v(&self) -> bool {
                *self == VREFR::EXT_3V
            }
        }
        #[doc = "Values that can be written to the field `VREF`"]
        pub enum VREFW {
            #[doc = "VDDA and GNDA are the voltage references"]
            INTERNAL,
            #[doc = "The external VREFA+ and VREFA- inputs are the voltage references"]
            EXT_3V,
        }
        impl VREFW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> bool {
                match *self {
                    VREFW::INTERNAL => false,
                    VREFW::EXT_3V => true,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VREFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VREFW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VREFW) -> &'a mut W {
                {
                    self.bit(variant._bits())
                }
            }
            #[doc = "VDDA and GNDA are the voltage references"]
            #[inline]
            pub fn internal(self) -> &'a mut W {
                self.variant(VREFW::INTERNAL)
            }
            #[doc = "The external VREFA+ and VREFA- inputs are the voltage references"]
            #[inline]
            pub fn ext_3v(self) -> &'a mut W {
                self.variant(VREFW::EXT_3V)
            }
            #[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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Voltage Reference Select"]
            #[inline]
            pub fn vref(&self) -> VREFR {
                VREFR::_from({
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                })
            }
        }
        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 = "Bit 0 - Voltage Reference Select"]
            #[inline]
            pub fn vref(&mut self) -> _VREFW {
                _VREFW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 0"]
    pub struct SSMUX0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 0"]
    pub mod ssmux0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSMUX0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX0R {
            bits: u8,
        }
        impl MUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX1R {
            bits: u8,
        }
        impl MUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX2R {
            bits: u8,
        }
        impl MUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX3R {
            bits: u8,
        }
        impl MUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX4R {
            bits: u8,
        }
        impl MUX4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX5R {
            bits: u8,
        }
        impl MUX5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX6R {
            bits: u8,
        }
        impl MUX6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX7R {
            bits: u8,
        }
        impl MUX7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _MUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX4W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX5W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX6W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX7W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&self) -> MUX0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX0R { bits }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&self) -> MUX1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX1R { bits }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&self) -> MUX2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX2R { bits }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&self) -> MUX3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX3R { bits }
            }
            #[doc = "Bits 16:19 - 5th Sample Input Select"]
            #[inline]
            pub fn mux4(&self) -> MUX4R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX4R { bits }
            }
            #[doc = "Bits 20:23 - 6th Sample Input Select"]
            #[inline]
            pub fn mux5(&self) -> MUX5R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX5R { bits }
            }
            #[doc = "Bits 24:27 - 7th Sample Input Select"]
            #[inline]
            pub fn mux6(&self) -> MUX6R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX6R { bits }
            }
            #[doc = "Bits 28:31 - 8th Sample Input Select"]
            #[inline]
            pub fn mux7(&self) -> MUX7R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX7R { bits }
            }
        }
        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 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&mut self) -> _MUX0W {
                _MUX0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&mut self) -> _MUX1W {
                _MUX1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&mut self) -> _MUX2W {
                _MUX2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&mut self) -> _MUX3W {
                _MUX3W { w: self }
            }
            #[doc = "Bits 16:19 - 5th Sample Input Select"]
            #[inline]
            pub fn mux4(&mut self) -> _MUX4W {
                _MUX4W { w: self }
            }
            #[doc = "Bits 20:23 - 6th Sample Input Select"]
            #[inline]
            pub fn mux5(&mut self) -> _MUX5W {
                _MUX5W { w: self }
            }
            #[doc = "Bits 24:27 - 7th Sample Input Select"]
            #[inline]
            pub fn mux6(&mut self) -> _MUX6W {
                _MUX6W { w: self }
            }
            #[doc = "Bits 28:31 - 8th Sample Input Select"]
            #[inline]
            pub fn mux7(&mut self) -> _MUX7W {
                _MUX7W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Control 0"]
    pub struct SSCTL0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Control 0"]
    pub mod ssctl0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSCTL0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END0R {
            bits: bool,
        }
        impl END0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE0R {
            bits: bool,
        }
        impl IE0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS0R {
            bits: bool,
        }
        impl TS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END1R {
            bits: bool,
        }
        impl END1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE1R {
            bits: bool,
        }
        impl IE1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS1R {
            bits: bool,
        }
        impl TS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END2R {
            bits: bool,
        }
        impl END2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE2R {
            bits: bool,
        }
        impl IE2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS2R {
            bits: bool,
        }
        impl TS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END3R {
            bits: bool,
        }
        impl END3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE3R {
            bits: bool,
        }
        impl IE3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS3R {
            bits: bool,
        }
        impl TS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D4R {
            bits: bool,
        }
        impl D4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END4R {
            bits: bool,
        }
        impl END4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE4R {
            bits: bool,
        }
        impl IE4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS4R {
            bits: bool,
        }
        impl TS4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D5R {
            bits: bool,
        }
        impl D5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END5R {
            bits: bool,
        }
        impl END5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE5R {
            bits: bool,
        }
        impl IE5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS5R {
            bits: bool,
        }
        impl TS5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D6R {
            bits: bool,
        }
        impl D6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END6R {
            bits: bool,
        }
        impl END6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE6R {
            bits: bool,
        }
        impl IE6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS6R {
            bits: bool,
        }
        impl TS6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D7R {
            bits: bool,
        }
        impl D7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END7R {
            bits: bool,
        }
        impl END7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE7R {
            bits: bool,
        }
        impl IE7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS7R {
            bits: bool,
        }
        impl TS7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _END0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END0W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE0W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END1W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE1W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS1W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END2W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS2W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END3W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE3W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS3W<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D4W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END4W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE4W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS4W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D5W<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END5W<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE5W<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS5W<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D6W<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END6W<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE6W<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS6W<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D7W<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END7W<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE7W<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS7W<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&self) -> END0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END0R { bits }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&self) -> IE0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE0R { bits }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&self) -> TS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS0R { bits }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&self) -> END1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END1R { bits }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&self) -> IE1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE1R { bits }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&self) -> TS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&self) -> END2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END2R { bits }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&self) -> IE2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE2R { bits }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&self) -> TS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&self) -> END3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END3R { bits }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&self) -> IE3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE3R { bits }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&self) -> TS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS3R { bits }
            }
            #[doc = "Bit 16 - 5th Sample Differential Input Select"]
            #[inline]
            pub fn d4(&self) -> D4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D4R { bits }
            }
            #[doc = "Bit 17 - 5th Sample is End of Sequence"]
            #[inline]
            pub fn end4(&self) -> END4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END4R { bits }
            }
            #[doc = "Bit 18 - 5th Sample Interrupt Enable"]
            #[inline]
            pub fn ie4(&self) -> IE4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE4R { bits }
            }
            #[doc = "Bit 19 - 5th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts4(&self) -> TS4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS4R { bits }
            }
            #[doc = "Bit 20 - 6th Sample Differential Input Select"]
            #[inline]
            pub fn d5(&self) -> D5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D5R { bits }
            }
            #[doc = "Bit 21 - 6th Sample is End of Sequence"]
            #[inline]
            pub fn end5(&self) -> END5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END5R { bits }
            }
            #[doc = "Bit 22 - 6th Sample Interrupt Enable"]
            #[inline]
            pub fn ie5(&self) -> IE5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE5R { bits }
            }
            #[doc = "Bit 23 - 6th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts5(&self) -> TS5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS5R { bits }
            }
            #[doc = "Bit 24 - 7th Sample Differential Input Select"]
            #[inline]
            pub fn d6(&self) -> D6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D6R { bits }
            }
            #[doc = "Bit 25 - 7th Sample is End of Sequence"]
            #[inline]
            pub fn end6(&self) -> END6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END6R { bits }
            }
            #[doc = "Bit 26 - 7th Sample Interrupt Enable"]
            #[inline]
            pub fn ie6(&self) -> IE6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE6R { bits }
            }
            #[doc = "Bit 27 - 7th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts6(&self) -> TS6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS6R { bits }
            }
            #[doc = "Bit 28 - 8th Sample Differential Input Select"]
            #[inline]
            pub fn d7(&self) -> D7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D7R { bits }
            }
            #[doc = "Bit 29 - 8th Sample is End of Sequence"]
            #[inline]
            pub fn end7(&self) -> END7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END7R { bits }
            }
            #[doc = "Bit 30 - 8th Sample Interrupt Enable"]
            #[inline]
            pub fn ie7(&self) -> IE7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE7R { bits }
            }
            #[doc = "Bit 31 - 8th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts7(&self) -> TS7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS7R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&mut self) -> _END0W {
                _END0W { w: self }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&mut self) -> _IE0W {
                _IE0W { w: self }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&mut self) -> _TS0W {
                _TS0W { w: self }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&mut self) -> _END1W {
                _END1W { w: self }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&mut self) -> _IE1W {
                _IE1W { w: self }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&mut self) -> _TS1W {
                _TS1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&mut self) -> _END2W {
                _END2W { w: self }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&mut self) -> _IE2W {
                _IE2W { w: self }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&mut self) -> _TS2W {
                _TS2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&mut self) -> _END3W {
                _END3W { w: self }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&mut self) -> _IE3W {
                _IE3W { w: self }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&mut self) -> _TS3W {
                _TS3W { w: self }
            }
            #[doc = "Bit 16 - 5th Sample Differential Input Select"]
            #[inline]
            pub fn d4(&mut self) -> _D4W {
                _D4W { w: self }
            }
            #[doc = "Bit 17 - 5th Sample is End of Sequence"]
            #[inline]
            pub fn end4(&mut self) -> _END4W {
                _END4W { w: self }
            }
            #[doc = "Bit 18 - 5th Sample Interrupt Enable"]
            #[inline]
            pub fn ie4(&mut self) -> _IE4W {
                _IE4W { w: self }
            }
            #[doc = "Bit 19 - 5th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts4(&mut self) -> _TS4W {
                _TS4W { w: self }
            }
            #[doc = "Bit 20 - 6th Sample Differential Input Select"]
            #[inline]
            pub fn d5(&mut self) -> _D5W {
                _D5W { w: self }
            }
            #[doc = "Bit 21 - 6th Sample is End of Sequence"]
            #[inline]
            pub fn end5(&mut self) -> _END5W {
                _END5W { w: self }
            }
            #[doc = "Bit 22 - 6th Sample Interrupt Enable"]
            #[inline]
            pub fn ie5(&mut self) -> _IE5W {
                _IE5W { w: self }
            }
            #[doc = "Bit 23 - 6th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts5(&mut self) -> _TS5W {
                _TS5W { w: self }
            }
            #[doc = "Bit 24 - 7th Sample Differential Input Select"]
            #[inline]
            pub fn d6(&mut self) -> _D6W {
                _D6W { w: self }
            }
            #[doc = "Bit 25 - 7th Sample is End of Sequence"]
            #[inline]
            pub fn end6(&mut self) -> _END6W {
                _END6W { w: self }
            }
            #[doc = "Bit 26 - 7th Sample Interrupt Enable"]
            #[inline]
            pub fn ie6(&mut self) -> _IE6W {
                _IE6W { w: self }
            }
            #[doc = "Bit 27 - 7th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts6(&mut self) -> _TS6W {
                _TS6W { w: self }
            }
            #[doc = "Bit 28 - 8th Sample Differential Input Select"]
            #[inline]
            pub fn d7(&mut self) -> _D7W {
                _D7W { w: self }
            }
            #[doc = "Bit 29 - 8th Sample is End of Sequence"]
            #[inline]
            pub fn end7(&mut self) -> _END7W {
                _END7W { w: self }
            }
            #[doc = "Bit 30 - 8th Sample Interrupt Enable"]
            #[inline]
            pub fn ie7(&mut self) -> _IE7W {
                _IE7W { w: self }
            }
            #[doc = "Bit 31 - 8th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts7(&mut self) -> _TS7W {
                _TS7W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Result FIFO 0"]
    pub struct SSFIFO0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Result FIFO 0"]
    pub mod ssfifo0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFIFO0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Conversion Result Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence FIFO 0 Status"]
    pub struct SSFSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence FIFO 0 Status"]
    pub mod ssfstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFSTAT0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPTRR {
            bits: u8,
        }
        impl TPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HPTRR {
            bits: u8,
        }
        impl HPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMPTYR {
            bits: bool,
        }
        impl EMPTYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - FIFO Tail Pointer"]
            #[inline]
            pub fn tptr(&self) -> TPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TPTRR { bits }
            }
            #[doc = "Bits 4:7 - FIFO Head Pointer"]
            #[inline]
            pub fn hptr(&self) -> HPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HPTRR { bits }
            }
            #[doc = "Bit 8 - FIFO Empty"]
            #[inline]
            pub fn empty(&self) -> EMPTYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMPTYR { bits }
            }
            #[doc = "Bit 12 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FULLR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence 0 Operation"]
    pub struct SSOP0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 0 Operation"]
    pub mod ssop0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSOP0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCOPR {
            bits: bool,
        }
        impl S0DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCOPR {
            bits: bool,
        }
        impl S1DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCOPR {
            bits: bool,
        }
        impl S2DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCOPR {
            bits: bool,
        }
        impl S3DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4DCOPR {
            bits: bool,
        }
        impl S4DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5DCOPR {
            bits: bool,
        }
        impl S5DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6DCOPR {
            bits: bool,
        }
        impl S6DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7DCOPR {
            bits: bool,
        }
        impl S7DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCOPW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCOPW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCOPW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCOPW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4DCOPW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5DCOPW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6DCOPW<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7DCOPW<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&self) -> S0DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0DCOPR { bits }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&self) -> S1DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1DCOPR { bits }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&self) -> S2DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2DCOPR { bits }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&self) -> S3DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3DCOPR { bits }
            }
            #[doc = "Bit 16 - Sample 4 Digital Comparator Operation"]
            #[inline]
            pub fn s4dcop(&self) -> S4DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S4DCOPR { bits }
            }
            #[doc = "Bit 20 - Sample 5 Digital Comparator Operation"]
            #[inline]
            pub fn s5dcop(&self) -> S5DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S5DCOPR { bits }
            }
            #[doc = "Bit 24 - Sample 6 Digital Comparator Operation"]
            #[inline]
            pub fn s6dcop(&self) -> S6DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S6DCOPR { bits }
            }
            #[doc = "Bit 28 - Sample 7 Digital Comparator Operation"]
            #[inline]
            pub fn s7dcop(&self) -> S7DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S7DCOPR { bits }
            }
        }
        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 = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&mut self) -> _S0DCOPW {
                _S0DCOPW { w: self }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&mut self) -> _S1DCOPW {
                _S1DCOPW { w: self }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&mut self) -> _S2DCOPW {
                _S2DCOPW { w: self }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&mut self) -> _S3DCOPW {
                _S3DCOPW { w: self }
            }
            #[doc = "Bit 16 - Sample 4 Digital Comparator Operation"]
            #[inline]
            pub fn s4dcop(&mut self) -> _S4DCOPW {
                _S4DCOPW { w: self }
            }
            #[doc = "Bit 20 - Sample 5 Digital Comparator Operation"]
            #[inline]
            pub fn s5dcop(&mut self) -> _S5DCOPW {
                _S5DCOPW { w: self }
            }
            #[doc = "Bit 24 - Sample 6 Digital Comparator Operation"]
            #[inline]
            pub fn s6dcop(&mut self) -> _S6DCOPW {
                _S6DCOPW { w: self }
            }
            #[doc = "Bit 28 - Sample 7 Digital Comparator Operation"]
            #[inline]
            pub fn s7dcop(&mut self) -> _S7DCOPW {
                _S7DCOPW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 0 Digital Comparator Select"]
    pub struct SSDC0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 0 Digital Comparator Select"]
    pub mod ssdc0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSDC0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCSELR {
            bits: u8,
        }
        impl S0DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCSELR {
            bits: u8,
        }
        impl S1DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCSELR {
            bits: u8,
        }
        impl S2DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCSELR {
            bits: u8,
        }
        impl S3DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4DCSELR {
            bits: u8,
        }
        impl S4DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5DCSELR {
            bits: u8,
        }
        impl S5DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6DCSELR {
            bits: u8,
        }
        impl S6DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7DCSELR {
            bits: u8,
        }
        impl S7DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _S3DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&self) -> S0DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S0DCSELR { bits }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&self) -> S1DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S1DCSELR { bits }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&self) -> S2DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S2DCSELR { bits }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&self) -> S3DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S3DCSELR { bits }
            }
            #[doc = "Bits 16:19 - Sample 4 Digital Comparator Select"]
            #[inline]
            pub fn s4dcsel(&self) -> S4DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S4DCSELR { bits }
            }
            #[doc = "Bits 20:23 - Sample 5 Digital Comparator Select"]
            #[inline]
            pub fn s5dcsel(&self) -> S5DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S5DCSELR { bits }
            }
            #[doc = "Bits 24:27 - Sample 6 Digital Comparator Select"]
            #[inline]
            pub fn s6dcsel(&self) -> S6DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S6DCSELR { bits }
            }
            #[doc = "Bits 28:31 - Sample 7 Digital Comparator Select"]
            #[inline]
            pub fn s7dcsel(&self) -> S7DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S7DCSELR { bits }
            }
        }
        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 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&mut self) -> _S0DCSELW {
                _S0DCSELW { w: self }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&mut self) -> _S1DCSELW {
                _S1DCSELW { w: self }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&mut self) -> _S2DCSELW {
                _S2DCSELW { w: self }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&mut self) -> _S3DCSELW {
                _S3DCSELW { w: self }
            }
            #[doc = "Bits 16:19 - Sample 4 Digital Comparator Select"]
            #[inline]
            pub fn s4dcsel(&mut self) -> _S4DCSELW {
                _S4DCSELW { w: self }
            }
            #[doc = "Bits 20:23 - Sample 5 Digital Comparator Select"]
            #[inline]
            pub fn s5dcsel(&mut self) -> _S5DCSELW {
                _S5DCSELW { w: self }
            }
            #[doc = "Bits 24:27 - Sample 6 Digital Comparator Select"]
            #[inline]
            pub fn s6dcsel(&mut self) -> _S6DCSELW {
                _S6DCSELW { w: self }
            }
            #[doc = "Bits 28:31 - Sample 7 Digital Comparator Select"]
            #[inline]
            pub fn s7dcsel(&mut self) -> _S7DCSELW {
                _S7DCSELW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 0"]
    pub struct SSEMUX0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 0"]
    pub mod ssemux0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSEMUX0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX0R {
            bits: bool,
        }
        impl EMUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX1R {
            bits: bool,
        }
        impl EMUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX2R {
            bits: bool,
        }
        impl EMUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX3R {
            bits: bool,
        }
        impl EMUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX4R {
            bits: bool,
        }
        impl EMUX4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX5R {
            bits: bool,
        }
        impl EMUX5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX6R {
            bits: bool,
        }
        impl EMUX6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX7R {
            bits: bool,
        }
        impl EMUX7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX4W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX5W<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX6W<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX7W<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&self) -> EMUX0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX0R { bits }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&self) -> EMUX1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&self) -> EMUX2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&self) -> EMUX3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX3R { bits }
            }
            #[doc = "Bit 16 - 5th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux4(&self) -> EMUX4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX4R { bits }
            }
            #[doc = "Bit 20 - 6th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux5(&self) -> EMUX5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX5R { bits }
            }
            #[doc = "Bit 24 - 7th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux6(&self) -> EMUX6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX6R { bits }
            }
            #[doc = "Bit 28 - 8th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux7(&self) -> EMUX7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX7R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&mut self) -> _EMUX0W {
                _EMUX0W { w: self }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&mut self) -> _EMUX1W {
                _EMUX1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&mut self) -> _EMUX2W {
                _EMUX2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&mut self) -> _EMUX3W {
                _EMUX3W { w: self }
            }
            #[doc = "Bit 16 - 5th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux4(&mut self) -> _EMUX4W {
                _EMUX4W { w: self }
            }
            #[doc = "Bit 20 - 6th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux5(&mut self) -> _EMUX5W {
                _EMUX5W { w: self }
            }
            #[doc = "Bit 24 - 7th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux6(&mut self) -> _EMUX6W {
                _EMUX6W { w: self }
            }
            #[doc = "Bit 28 - 8th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux7(&mut self) -> _EMUX7W {
                _EMUX7W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 0 Sample and Hold Time"]
    pub struct SSTSH0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 0 Sample and Hold Time"]
    pub mod sstsh0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSTSH0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `TSH0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH0R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH0R::_4 => 0,
                    TSH0R::_8 => 0x02,
                    TSH0R::_16 => 0x04,
                    TSH0R::_32 => 0x06,
                    TSH0R::_64 => 0x08,
                    TSH0R::_128 => 0x0a,
                    TSH0R::_256 => 0x0c,
                    TSH0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH0R {
                match value {
                    0 => TSH0R::_4,
                    2 => TSH0R::_8,
                    4 => TSH0R::_16,
                    6 => TSH0R::_32,
                    8 => TSH0R::_64,
                    10 => TSH0R::_128,
                    12 => TSH0R::_256,
                    i => TSH0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH0R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH0R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH0R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH0R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH0R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH0R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH0R::_256
            }
        }
        #[doc = "Possible values of the field `TSH1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH1R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH1R::_4 => 0,
                    TSH1R::_8 => 0x02,
                    TSH1R::_16 => 0x04,
                    TSH1R::_32 => 0x06,
                    TSH1R::_64 => 0x08,
                    TSH1R::_128 => 0x0a,
                    TSH1R::_256 => 0x0c,
                    TSH1R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH1R {
                match value {
                    0 => TSH1R::_4,
                    2 => TSH1R::_8,
                    4 => TSH1R::_16,
                    6 => TSH1R::_32,
                    8 => TSH1R::_64,
                    10 => TSH1R::_128,
                    12 => TSH1R::_256,
                    i => TSH1R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH1R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH1R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH1R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH1R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH1R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH1R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH1R::_256
            }
        }
        #[doc = "Possible values of the field `TSH2`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH2R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH2R::_4 => 0,
                    TSH2R::_8 => 0x02,
                    TSH2R::_16 => 0x04,
                    TSH2R::_32 => 0x06,
                    TSH2R::_64 => 0x08,
                    TSH2R::_128 => 0x0a,
                    TSH2R::_256 => 0x0c,
                    TSH2R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH2R {
                match value {
                    0 => TSH2R::_4,
                    2 => TSH2R::_8,
                    4 => TSH2R::_16,
                    6 => TSH2R::_32,
                    8 => TSH2R::_64,
                    10 => TSH2R::_128,
                    12 => TSH2R::_256,
                    i => TSH2R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH2R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH2R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH2R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH2R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH2R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH2R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH2R::_256
            }
        }
        #[doc = "Possible values of the field `TSH3`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH3R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH3R::_4 => 0,
                    TSH3R::_8 => 0x02,
                    TSH3R::_16 => 0x04,
                    TSH3R::_32 => 0x06,
                    TSH3R::_64 => 0x08,
                    TSH3R::_128 => 0x0a,
                    TSH3R::_256 => 0x0c,
                    TSH3R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH3R {
                match value {
                    0 => TSH3R::_4,
                    2 => TSH3R::_8,
                    4 => TSH3R::_16,
                    6 => TSH3R::_32,
                    8 => TSH3R::_64,
                    10 => TSH3R::_128,
                    12 => TSH3R::_256,
                    i => TSH3R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH3R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH3R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH3R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH3R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH3R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH3R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH3R::_256
            }
        }
        #[doc = "Possible values of the field `TSH4`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH4R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH4R::_4 => 0,
                    TSH4R::_8 => 0x02,
                    TSH4R::_16 => 0x04,
                    TSH4R::_32 => 0x06,
                    TSH4R::_64 => 0x08,
                    TSH4R::_128 => 0x0a,
                    TSH4R::_256 => 0x0c,
                    TSH4R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH4R {
                match value {
                    0 => TSH4R::_4,
                    2 => TSH4R::_8,
                    4 => TSH4R::_16,
                    6 => TSH4R::_32,
                    8 => TSH4R::_64,
                    10 => TSH4R::_128,
                    12 => TSH4R::_256,
                    i => TSH4R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH4R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH4R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH4R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH4R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH4R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH4R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH4R::_256
            }
        }
        #[doc = "Possible values of the field `TSH5`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH5R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH5R::_4 => 0,
                    TSH5R::_8 => 0x02,
                    TSH5R::_16 => 0x04,
                    TSH5R::_32 => 0x06,
                    TSH5R::_64 => 0x08,
                    TSH5R::_128 => 0x0a,
                    TSH5R::_256 => 0x0c,
                    TSH5R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH5R {
                match value {
                    0 => TSH5R::_4,
                    2 => TSH5R::_8,
                    4 => TSH5R::_16,
                    6 => TSH5R::_32,
                    8 => TSH5R::_64,
                    10 => TSH5R::_128,
                    12 => TSH5R::_256,
                    i => TSH5R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH5R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH5R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH5R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH5R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH5R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH5R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH5R::_256
            }
        }
        #[doc = "Possible values of the field `TSH6`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH6R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH6R::_4 => 0,
                    TSH6R::_8 => 0x02,
                    TSH6R::_16 => 0x04,
                    TSH6R::_32 => 0x06,
                    TSH6R::_64 => 0x08,
                    TSH6R::_128 => 0x0a,
                    TSH6R::_256 => 0x0c,
                    TSH6R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH6R {
                match value {
                    0 => TSH6R::_4,
                    2 => TSH6R::_8,
                    4 => TSH6R::_16,
                    6 => TSH6R::_32,
                    8 => TSH6R::_64,
                    10 => TSH6R::_128,
                    12 => TSH6R::_256,
                    i => TSH6R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH6R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH6R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH6R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH6R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH6R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH6R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH6R::_256
            }
        }
        #[doc = "Possible values of the field `TSH7`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSH7R {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSH7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSH7R::_4 => 0,
                    TSH7R::_8 => 0x02,
                    TSH7R::_16 => 0x04,
                    TSH7R::_32 => 0x06,
                    TSH7R::_64 => 0x08,
                    TSH7R::_128 => 0x0a,
                    TSH7R::_256 => 0x0c,
                    TSH7R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSH7R {
                match value {
                    0 => TSH7R::_4,
                    2 => TSH7R::_8,
                    4 => TSH7R::_16,
                    6 => TSH7R::_32,
                    8 => TSH7R::_64,
                    10 => TSH7R::_128,
                    12 => TSH7R::_256,
                    i => TSH7R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == TSH7R::_4
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == TSH7R::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TSH7R::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TSH7R::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TSH7R::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TSH7R::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TSH7R::_256
            }
        }
        #[doc = "Values that can be written to the field `TSH0`"]
        pub enum TSH0W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH0W::_4 => 0,
                    TSH0W::_8 => 2,
                    TSH0W::_16 => 4,
                    TSH0W::_32 => 6,
                    TSH0W::_64 => 8,
                    TSH0W::_128 => 10,
                    TSH0W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH0W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH0W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH0W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH0W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH0W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH0W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH0W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH1`"]
        pub enum TSH1W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH1W::_4 => 0,
                    TSH1W::_8 => 2,
                    TSH1W::_16 => 4,
                    TSH1W::_32 => 6,
                    TSH1W::_64 => 8,
                    TSH1W::_128 => 10,
                    TSH1W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH1W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH1W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH1W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH1W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH1W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH1W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH1W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH1W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH2`"]
        pub enum TSH2W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH2W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH2W::_4 => 0,
                    TSH2W::_8 => 2,
                    TSH2W::_16 => 4,
                    TSH2W::_32 => 6,
                    TSH2W::_64 => 8,
                    TSH2W::_128 => 10,
                    TSH2W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH2W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH2W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH2W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH2W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH2W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH2W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH2W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH2W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH2W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH3`"]
        pub enum TSH3W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH3W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH3W::_4 => 0,
                    TSH3W::_8 => 2,
                    TSH3W::_16 => 4,
                    TSH3W::_32 => 6,
                    TSH3W::_64 => 8,
                    TSH3W::_128 => 10,
                    TSH3W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH3W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH3W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH3W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH3W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH3W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH3W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH3W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH3W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH3W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH4`"]
        pub enum TSH4W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH4W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH4W::_4 => 0,
                    TSH4W::_8 => 2,
                    TSH4W::_16 => 4,
                    TSH4W::_32 => 6,
                    TSH4W::_64 => 8,
                    TSH4W::_128 => 10,
                    TSH4W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH4W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH4W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH4W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH4W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH4W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH4W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH4W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH4W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH4W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH5`"]
        pub enum TSH5W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH5W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH5W::_4 => 0,
                    TSH5W::_8 => 2,
                    TSH5W::_16 => 4,
                    TSH5W::_32 => 6,
                    TSH5W::_64 => 8,
                    TSH5W::_128 => 10,
                    TSH5W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH5W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH5W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH5W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH5W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH5W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH5W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH5W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH5W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH5W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH6`"]
        pub enum TSH6W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH6W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH6W::_4 => 0,
                    TSH6W::_8 => 2,
                    TSH6W::_16 => 4,
                    TSH6W::_32 => 6,
                    TSH6W::_64 => 8,
                    TSH6W::_128 => 10,
                    TSH6W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH6W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH6W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH6W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH6W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH6W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH6W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH6W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH6W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH6W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSH7`"]
        pub enum TSH7W {
            #[doc = "N_SH = 4"]
            _4,
            #[doc = "N_SH = 8"]
            _8,
            #[doc = "N_SH = 16"]
            _16,
            #[doc = "N_SH = 32"]
            _32,
            #[doc = "N_SH = 64"]
            _64,
            #[doc = "N_SH = 128"]
            _128,
            #[doc = "N_SH = 256"]
            _256,
        }
        impl TSH7W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSH7W::_4 => 0,
                    TSH7W::_8 => 2,
                    TSH7W::_16 => 4,
                    TSH7W::_32 => 6,
                    TSH7W::_64 => 8,
                    TSH7W::_128 => 10,
                    TSH7W::_256 => 12,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH7W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSH7W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "N_SH = 4"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(TSH7W::_4)
            }
            #[doc = "N_SH = 8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(TSH7W::_8)
            }
            #[doc = "N_SH = 16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TSH7W::_16)
            }
            #[doc = "N_SH = 32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TSH7W::_32)
            }
            #[doc = "N_SH = 64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TSH7W::_64)
            }
            #[doc = "N_SH = 128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TSH7W::_128)
            }
            #[doc = "N_SH = 256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TSH7W::_256)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&self) -> TSH0R {
                TSH0R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&self) -> TSH1R {
                TSH1R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&self) -> TSH2R {
                TSH2R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&self) -> TSH3R {
                TSH3R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:19 - 5th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh4(&self) -> TSH4R {
                TSH4R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 20:23 - 6th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh5(&self) -> TSH5R {
                TSH5R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:27 - 7th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh6(&self) -> TSH6R {
                TSH6R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 28:31 - 8th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh7(&self) -> TSH7R {
                TSH7R::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&mut self) -> _TSH0W {
                _TSH0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&mut self) -> _TSH1W {
                _TSH1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&mut self) -> _TSH2W {
                _TSH2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&mut self) -> _TSH3W {
                _TSH3W { w: self }
            }
            #[doc = "Bits 16:19 - 5th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh4(&mut self) -> _TSH4W {
                _TSH4W { w: self }
            }
            #[doc = "Bits 20:23 - 6th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh5(&mut self) -> _TSH5W {
                _TSH5W { w: self }
            }
            #[doc = "Bits 24:27 - 7th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh6(&mut self) -> _TSH6W {
                _TSH6W { w: self }
            }
            #[doc = "Bits 28:31 - 8th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh7(&mut self) -> _TSH7W {
                _TSH7W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 1"]
    pub struct SSMUX1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 1"]
    pub mod ssmux1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSMUX1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX0R {
            bits: u8,
        }
        impl MUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX1R {
            bits: u8,
        }
        impl MUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX2R {
            bits: u8,
        }
        impl MUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX3R {
            bits: u8,
        }
        impl MUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _MUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&self) -> MUX0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX0R { bits }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&self) -> MUX1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX1R { bits }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&self) -> MUX2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX2R { bits }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&self) -> MUX3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX3R { bits }
            }
        }
        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 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&mut self) -> _MUX0W {
                _MUX0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&mut self) -> _MUX1W {
                _MUX1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&mut self) -> _MUX2W {
                _MUX2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&mut self) -> _MUX3W {
                _MUX3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Control 1"]
    pub struct SSCTL1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Control 1"]
    pub mod ssctl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSCTL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END0R {
            bits: bool,
        }
        impl END0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE0R {
            bits: bool,
        }
        impl IE0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS0R {
            bits: bool,
        }
        impl TS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END1R {
            bits: bool,
        }
        impl END1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE1R {
            bits: bool,
        }
        impl IE1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS1R {
            bits: bool,
        }
        impl TS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END2R {
            bits: bool,
        }
        impl END2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE2R {
            bits: bool,
        }
        impl IE2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS2R {
            bits: bool,
        }
        impl TS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END3R {
            bits: bool,
        }
        impl END3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE3R {
            bits: bool,
        }
        impl IE3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS3R {
            bits: bool,
        }
        impl TS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _END0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END0W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE0W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END1W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE1W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS1W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END2W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS2W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END3W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE3W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS3W<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&self) -> END0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END0R { bits }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&self) -> IE0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE0R { bits }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&self) -> TS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS0R { bits }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&self) -> END1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END1R { bits }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&self) -> IE1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE1R { bits }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&self) -> TS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&self) -> END2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END2R { bits }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&self) -> IE2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE2R { bits }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&self) -> TS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&self) -> END3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END3R { bits }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&self) -> IE3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE3R { bits }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&self) -> TS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS3R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&mut self) -> _END0W {
                _END0W { w: self }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&mut self) -> _IE0W {
                _IE0W { w: self }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&mut self) -> _TS0W {
                _TS0W { w: self }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&mut self) -> _END1W {
                _END1W { w: self }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&mut self) -> _IE1W {
                _IE1W { w: self }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&mut self) -> _TS1W {
                _TS1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&mut self) -> _END2W {
                _END2W { w: self }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&mut self) -> _IE2W {
                _IE2W { w: self }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&mut self) -> _TS2W {
                _TS2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&mut self) -> _END3W {
                _END3W { w: self }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&mut self) -> _IE3W {
                _IE3W { w: self }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&mut self) -> _TS3W {
                _TS3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Result FIFO 1"]
    pub struct SSFIFO1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Result FIFO 1"]
    pub mod ssfifo1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFIFO1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Conversion Result Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence FIFO 1 Status"]
    pub struct SSFSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence FIFO 1 Status"]
    pub mod ssfstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFSTAT1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPTRR {
            bits: u8,
        }
        impl TPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HPTRR {
            bits: u8,
        }
        impl HPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMPTYR {
            bits: bool,
        }
        impl EMPTYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - FIFO Tail Pointer"]
            #[inline]
            pub fn tptr(&self) -> TPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TPTRR { bits }
            }
            #[doc = "Bits 4:7 - FIFO Head Pointer"]
            #[inline]
            pub fn hptr(&self) -> HPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HPTRR { bits }
            }
            #[doc = "Bit 8 - FIFO Empty"]
            #[inline]
            pub fn empty(&self) -> EMPTYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMPTYR { bits }
            }
            #[doc = "Bit 12 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FULLR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence 1 Operation"]
    pub struct SSOP1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 1 Operation"]
    pub mod ssop1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSOP1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCOPR {
            bits: bool,
        }
        impl S0DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCOPR {
            bits: bool,
        }
        impl S1DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCOPR {
            bits: bool,
        }
        impl S2DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCOPR {
            bits: bool,
        }
        impl S3DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCOPW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCOPW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCOPW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCOPW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&self) -> S0DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0DCOPR { bits }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&self) -> S1DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1DCOPR { bits }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&self) -> S2DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2DCOPR { bits }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&self) -> S3DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3DCOPR { bits }
            }
        }
        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 = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&mut self) -> _S0DCOPW {
                _S0DCOPW { w: self }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&mut self) -> _S1DCOPW {
                _S1DCOPW { w: self }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&mut self) -> _S2DCOPW {
                _S2DCOPW { w: self }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&mut self) -> _S3DCOPW {
                _S3DCOPW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 1 Digital Comparator Select"]
    pub struct SSDC1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 1 Digital Comparator Select"]
    pub mod ssdc1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSDC1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCSELR {
            bits: u8,
        }
        impl S0DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCSELR {
            bits: u8,
        }
        impl S1DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCSELR {
            bits: u8,
        }
        impl S2DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCSELR {
            bits: u8,
        }
        impl S3DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _S3DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&self) -> S0DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S0DCSELR { bits }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&self) -> S1DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S1DCSELR { bits }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&self) -> S2DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S2DCSELR { bits }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&self) -> S3DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S3DCSELR { bits }
            }
        }
        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 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&mut self) -> _S0DCSELW {
                _S0DCSELW { w: self }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&mut self) -> _S1DCSELW {
                _S1DCSELW { w: self }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&mut self) -> _S2DCSELW {
                _S2DCSELW { w: self }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&mut self) -> _S3DCSELW {
                _S3DCSELW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 1"]
    pub struct SSEMUX1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 1"]
    pub mod ssemux1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSEMUX1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX0R {
            bits: bool,
        }
        impl EMUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX1R {
            bits: bool,
        }
        impl EMUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX2R {
            bits: bool,
        }
        impl EMUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX3R {
            bits: bool,
        }
        impl EMUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&self) -> EMUX0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX0R { bits }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&self) -> EMUX1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&self) -> EMUX2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&self) -> EMUX3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX3R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&mut self) -> _EMUX0W {
                _EMUX0W { w: self }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&mut self) -> _EMUX1W {
                _EMUX1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&mut self) -> _EMUX2W {
                _EMUX2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&mut self) -> _EMUX3W {
                _EMUX3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 1 Sample and Hold Time"]
    pub struct SSTSH1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 1 Sample and Hold Time"]
    pub mod sstsh1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSTSH1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH0R {
            bits: u8,
        }
        impl TSH0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH1R {
            bits: u8,
        }
        impl TSH1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH2R {
            bits: u8,
        }
        impl TSH2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH3R {
            bits: u8,
        }
        impl TSH3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _TSH3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&self) -> TSH0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH0R { bits }
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&self) -> TSH1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH1R { bits }
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&self) -> TSH2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH2R { bits }
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&self) -> TSH3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH3R { bits }
            }
        }
        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 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&mut self) -> _TSH0W {
                _TSH0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&mut self) -> _TSH1W {
                _TSH1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&mut self) -> _TSH2W {
                _TSH2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&mut self) -> _TSH3W {
                _TSH3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 2"]
    pub struct SSMUX2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 2"]
    pub mod ssmux2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSMUX2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX0R {
            bits: u8,
        }
        impl MUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX1R {
            bits: u8,
        }
        impl MUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX2R {
            bits: u8,
        }
        impl MUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX3R {
            bits: u8,
        }
        impl MUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _MUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&self) -> MUX0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX0R { bits }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&self) -> MUX1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX1R { bits }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&self) -> MUX2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX2R { bits }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&self) -> MUX3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX3R { bits }
            }
        }
        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 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&mut self) -> _MUX0W {
                _MUX0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample Input Select"]
            #[inline]
            pub fn mux1(&mut self) -> _MUX1W {
                _MUX1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample Input Select"]
            #[inline]
            pub fn mux2(&mut self) -> _MUX2W {
                _MUX2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample Input Select"]
            #[inline]
            pub fn mux3(&mut self) -> _MUX3W {
                _MUX3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Control 2"]
    pub struct SSCTL2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Control 2"]
    pub mod ssctl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSCTL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END0R {
            bits: bool,
        }
        impl END0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE0R {
            bits: bool,
        }
        impl IE0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS0R {
            bits: bool,
        }
        impl TS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END1R {
            bits: bool,
        }
        impl END1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE1R {
            bits: bool,
        }
        impl IE1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS1R {
            bits: bool,
        }
        impl TS1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END2R {
            bits: bool,
        }
        impl END2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE2R {
            bits: bool,
        }
        impl IE2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS2R {
            bits: bool,
        }
        impl TS2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END3R {
            bits: bool,
        }
        impl END3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE3R {
            bits: bool,
        }
        impl IE3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS3R {
            bits: bool,
        }
        impl TS3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _END0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END0W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE0W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END1W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE1W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS1W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END2W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS2W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _END3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END3W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE3W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS3W<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&self) -> END0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END0R { bits }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&self) -> IE0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE0R { bits }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&self) -> TS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS0R { bits }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&self) -> END1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END1R { bits }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&self) -> IE1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE1R { bits }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&self) -> TS1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&self) -> END2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END2R { bits }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&self) -> IE2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE2R { bits }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&self) -> TS2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&self) -> END3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END3R { bits }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&self) -> IE3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE3R { bits }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&self) -> TS3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS3R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Differential Input Select"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - 1st Sample is End of Sequence"]
            #[inline]
            pub fn end0(&mut self) -> _END0W {
                _END0W { w: self }
            }
            #[doc = "Bit 2 - 1st Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&mut self) -> _IE0W {
                _IE0W { w: self }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&mut self) -> _TS0W {
                _TS0W { w: self }
            }
            #[doc = "Bit 4 - 2nd Sample Differential Input Select"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 5 - 2nd Sample is End of Sequence"]
            #[inline]
            pub fn end1(&mut self) -> _END1W {
                _END1W { w: self }
            }
            #[doc = "Bit 6 - 2nd Sample Interrupt Enable"]
            #[inline]
            pub fn ie1(&mut self) -> _IE1W {
                _IE1W { w: self }
            }
            #[doc = "Bit 7 - 2nd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts1(&mut self) -> _TS1W {
                _TS1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Differential Input Select"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 9 - 3rd Sample is End of Sequence"]
            #[inline]
            pub fn end2(&mut self) -> _END2W {
                _END2W { w: self }
            }
            #[doc = "Bit 10 - 3rd Sample Interrupt Enable"]
            #[inline]
            pub fn ie2(&mut self) -> _IE2W {
                _IE2W { w: self }
            }
            #[doc = "Bit 11 - 3rd Sample Temp Sensor Select"]
            #[inline]
            pub fn ts2(&mut self) -> _TS2W {
                _TS2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Differential Input Select"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 13 - 4th Sample is End of Sequence"]
            #[inline]
            pub fn end3(&mut self) -> _END3W {
                _END3W { w: self }
            }
            #[doc = "Bit 14 - 4th Sample Interrupt Enable"]
            #[inline]
            pub fn ie3(&mut self) -> _IE3W {
                _IE3W { w: self }
            }
            #[doc = "Bit 15 - 4th Sample Temp Sensor Select"]
            #[inline]
            pub fn ts3(&mut self) -> _TS3W {
                _TS3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Result FIFO 2"]
    pub struct SSFIFO2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Result FIFO 2"]
    pub mod ssfifo2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFIFO2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Conversion Result Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence FIFO 2 Status"]
    pub struct SSFSTAT2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence FIFO 2 Status"]
    pub mod ssfstat2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFSTAT2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPTRR {
            bits: u8,
        }
        impl TPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HPTRR {
            bits: u8,
        }
        impl HPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMPTYR {
            bits: bool,
        }
        impl EMPTYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - FIFO Tail Pointer"]
            #[inline]
            pub fn tptr(&self) -> TPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TPTRR { bits }
            }
            #[doc = "Bits 4:7 - FIFO Head Pointer"]
            #[inline]
            pub fn hptr(&self) -> HPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HPTRR { bits }
            }
            #[doc = "Bit 8 - FIFO Empty"]
            #[inline]
            pub fn empty(&self) -> EMPTYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMPTYR { bits }
            }
            #[doc = "Bit 12 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FULLR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence 2 Operation"]
    pub struct SSOP2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 2 Operation"]
    pub mod ssop2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSOP2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCOPR {
            bits: bool,
        }
        impl S0DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCOPR {
            bits: bool,
        }
        impl S1DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCOPR {
            bits: bool,
        }
        impl S2DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCOPR {
            bits: bool,
        }
        impl S3DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCOPW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCOPW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCOPW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCOPW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&self) -> S0DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0DCOPR { bits }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&self) -> S1DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1DCOPR { bits }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&self) -> S2DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2DCOPR { bits }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&self) -> S3DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3DCOPR { bits }
            }
        }
        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 = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&mut self) -> _S0DCOPW {
                _S0DCOPW { w: self }
            }
            #[doc = "Bit 4 - Sample 1 Digital Comparator Operation"]
            #[inline]
            pub fn s1dcop(&mut self) -> _S1DCOPW {
                _S1DCOPW { w: self }
            }
            #[doc = "Bit 8 - Sample 2 Digital Comparator Operation"]
            #[inline]
            pub fn s2dcop(&mut self) -> _S2DCOPW {
                _S2DCOPW { w: self }
            }
            #[doc = "Bit 12 - Sample 3 Digital Comparator Operation"]
            #[inline]
            pub fn s3dcop(&mut self) -> _S3DCOPW {
                _S3DCOPW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 2 Digital Comparator Select"]
    pub struct SSDC2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 2 Digital Comparator Select"]
    pub mod ssdc2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSDC2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCSELR {
            bits: u8,
        }
        impl S0DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1DCSELR {
            bits: u8,
        }
        impl S1DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2DCSELR {
            bits: u8,
        }
        impl S2DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3DCSELR {
            bits: u8,
        }
        impl S3DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _S3DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&self) -> S0DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S0DCSELR { bits }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&self) -> S1DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S1DCSELR { bits }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&self) -> S2DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S2DCSELR { bits }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&self) -> S3DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S3DCSELR { bits }
            }
        }
        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 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&mut self) -> _S0DCSELW {
                _S0DCSELW { w: self }
            }
            #[doc = "Bits 4:7 - Sample 1 Digital Comparator Select"]
            #[inline]
            pub fn s1dcsel(&mut self) -> _S1DCSELW {
                _S1DCSELW { w: self }
            }
            #[doc = "Bits 8:11 - Sample 2 Digital Comparator Select"]
            #[inline]
            pub fn s2dcsel(&mut self) -> _S2DCSELW {
                _S2DCSELW { w: self }
            }
            #[doc = "Bits 12:15 - Sample 3 Digital Comparator Select"]
            #[inline]
            pub fn s3dcsel(&mut self) -> _S3DCSELW {
                _S3DCSELW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 2"]
    pub struct SSEMUX2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 2"]
    pub mod ssemux2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSEMUX2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX0R {
            bits: bool,
        }
        impl EMUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX1R {
            bits: bool,
        }
        impl EMUX1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX2R {
            bits: bool,
        }
        impl EMUX2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX3R {
            bits: bool,
        }
        impl EMUX3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX1W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX2W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX3W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&self) -> EMUX0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX0R { bits }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&self) -> EMUX1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX1R { bits }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&self) -> EMUX2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX2R { bits }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&self) -> EMUX3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX3R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&mut self) -> _EMUX0W {
                _EMUX0W { w: self }
            }
            #[doc = "Bit 4 - 2th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux1(&mut self) -> _EMUX1W {
                _EMUX1W { w: self }
            }
            #[doc = "Bit 8 - 3rd Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux2(&mut self) -> _EMUX2W {
                _EMUX2W { w: self }
            }
            #[doc = "Bit 12 - 4th Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux3(&mut self) -> _EMUX3W {
                _EMUX3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 2 Sample and Hold Time"]
    pub struct SSTSH2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 2 Sample and Hold Time"]
    pub mod sstsh2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSTSH2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH0R {
            bits: u8,
        }
        impl TSH0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH1R {
            bits: u8,
        }
        impl TSH1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH2R {
            bits: u8,
        }
        impl TSH2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH3R {
            bits: u8,
        }
        impl TSH3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _TSH3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&self) -> TSH0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH0R { bits }
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&self) -> TSH1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH1R { bits }
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&self) -> TSH2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH2R { bits }
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&self) -> TSH3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH3R { bits }
            }
        }
        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 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&mut self) -> _TSH0W {
                _TSH0W { w: self }
            }
            #[doc = "Bits 4:7 - 2nd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh1(&mut self) -> _TSH1W {
                _TSH1W { w: self }
            }
            #[doc = "Bits 8:11 - 3rd Sample and Hold Period Select"]
            #[inline]
            pub fn tsh2(&mut self) -> _TSH2W {
                _TSH2W { w: self }
            }
            #[doc = "Bits 12:15 - 4th Sample and Hold Period Select"]
            #[inline]
            pub fn tsh3(&mut self) -> _TSH3W {
                _TSH3W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 3"]
    pub struct SSMUX3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Input Multiplexer Select 3"]
    pub mod ssmux3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSMUX3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MUX0R {
            bits: u8,
        }
        impl MUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _MUX0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&self) -> MUX0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MUX0R { bits }
            }
        }
        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 0:3 - 1st Sample Input Select"]
            #[inline]
            pub fn mux0(&mut self) -> _MUX0W {
                _MUX0W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Control 3"]
    pub struct SSCTL3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Control 3"]
    pub mod ssctl3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSCTL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct END0R {
            bits: bool,
        }
        impl END0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IE0R {
            bits: bool,
        }
        impl IE0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TS0R {
            bits: bool,
        }
        impl TS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _END0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _END0W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IE0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IE0W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TS0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Sample Differential Input Select"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - End of Sequence"]
            #[inline]
            pub fn end0(&self) -> END0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                END0R { bits }
            }
            #[doc = "Bit 2 - Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&self) -> IE0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IE0R { bits }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&self) -> TS0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TS0R { bits }
            }
        }
        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 = "Bit 0 - Sample Differential Input Select"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - End of Sequence"]
            #[inline]
            pub fn end0(&mut self) -> _END0W {
                _END0W { w: self }
            }
            #[doc = "Bit 2 - Sample Interrupt Enable"]
            #[inline]
            pub fn ie0(&mut self) -> _IE0W {
                _IE0W { w: self }
            }
            #[doc = "Bit 3 - 1st Sample Temp Sensor Select"]
            #[inline]
            pub fn ts0(&mut self) -> _TS0W {
                _TS0W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Result FIFO 3"]
    pub struct SSFIFO3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Result FIFO 3"]
    pub mod ssfifo3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFIFO3 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Conversion Result Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence FIFO 3 Status"]
    pub struct SSFSTAT3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence FIFO 3 Status"]
    pub mod ssfstat3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSFSTAT3 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPTRR {
            bits: u8,
        }
        impl TPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HPTRR {
            bits: u8,
        }
        impl HPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMPTYR {
            bits: bool,
        }
        impl EMPTYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - FIFO Tail Pointer"]
            #[inline]
            pub fn tptr(&self) -> TPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TPTRR { bits }
            }
            #[doc = "Bits 4:7 - FIFO Head Pointer"]
            #[inline]
            pub fn hptr(&self) -> HPTRR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HPTRR { bits }
            }
            #[doc = "Bit 8 - FIFO Empty"]
            #[inline]
            pub fn empty(&self) -> EMPTYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMPTYR { bits }
            }
            #[doc = "Bit 12 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FULLR { bits }
            }
        }
    }
    #[doc = "ADC Sample Sequence 3 Operation"]
    pub struct SSOP3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 3 Operation"]
    pub mod ssop3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSOP3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCOPR {
            bits: bool,
        }
        impl S0DCOPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCOPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCOPW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&self) -> S0DCOPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0DCOPR { bits }
            }
        }
        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 = "Bit 0 - Sample 0 Digital Comparator Operation"]
            #[inline]
            pub fn s0dcop(&mut self) -> _S0DCOPW {
                _S0DCOPW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 3 Digital Comparator Select"]
    pub struct SSDC3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 3 Digital Comparator Select"]
    pub mod ssdc3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSDC3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0DCSELR {
            bits: u8,
        }
        impl S0DCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0DCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0DCSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&self) -> S0DCSELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                S0DCSELR { bits }
            }
        }
        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 0:3 - Sample 0 Digital Comparator Select"]
            #[inline]
            pub fn s0dcsel(&mut self) -> _S0DCSELW {
                _S0DCSELW { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 3"]
    pub struct SSEMUX3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence Extended Input Multiplexer Select 3"]
    pub mod ssemux3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSEMUX3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMUX0R {
            bits: bool,
        }
        impl EMUX0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMUX0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMUX0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&self) -> EMUX0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMUX0R { bits }
            }
        }
        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 = "Bit 0 - 1st Sample Input Select (Upper Bit)"]
            #[inline]
            pub fn emux0(&mut self) -> _EMUX0W {
                _EMUX0W { w: self }
            }
        }
    }
    #[doc = "ADC Sample Sequence 3 Sample and Hold Time"]
    pub struct SSTSH3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Sample Sequence 3 Sample and Hold Time"]
    pub mod sstsh3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SSTSH3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSH0R {
            bits: u8,
        }
        impl TSH0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSH0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSH0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&self) -> TSH0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSH0R { bits }
            }
        }
        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 0:3 - 1st Sample and Hold Period Select"]
            #[inline]
            pub fn tsh0(&mut self) -> _TSH0W {
                _TSH0W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Reset Initial Conditions"]
    pub struct DCRIC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Reset Initial Conditions"]
    pub mod dcric {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCRIC {
            #[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 _DCINT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCINT7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCINT7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG0W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG1W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG3W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG4W<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG5W<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG6W<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCTRIG7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCTRIG7W<'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 = 23;
                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 = "Bit 0 - Digital Comparator Interrupt 0"]
            #[inline]
            pub fn dcint0(&mut self) -> _DCINT0W {
                _DCINT0W { w: self }
            }
            #[doc = "Bit 1 - Digital Comparator Interrupt 1"]
            #[inline]
            pub fn dcint1(&mut self) -> _DCINT1W {
                _DCINT1W { w: self }
            }
            #[doc = "Bit 2 - Digital Comparator Interrupt 2"]
            #[inline]
            pub fn dcint2(&mut self) -> _DCINT2W {
                _DCINT2W { w: self }
            }
            #[doc = "Bit 3 - Digital Comparator Interrupt 3"]
            #[inline]
            pub fn dcint3(&mut self) -> _DCINT3W {
                _DCINT3W { w: self }
            }
            #[doc = "Bit 4 - Digital Comparator Interrupt 4"]
            #[inline]
            pub fn dcint4(&mut self) -> _DCINT4W {
                _DCINT4W { w: self }
            }
            #[doc = "Bit 5 - Digital Comparator Interrupt 5"]
            #[inline]
            pub fn dcint5(&mut self) -> _DCINT5W {
                _DCINT5W { w: self }
            }
            #[doc = "Bit 6 - Digital Comparator Interrupt 6"]
            #[inline]
            pub fn dcint6(&mut self) -> _DCINT6W {
                _DCINT6W { w: self }
            }
            #[doc = "Bit 7 - Digital Comparator Interrupt 7"]
            #[inline]
            pub fn dcint7(&mut self) -> _DCINT7W {
                _DCINT7W { w: self }
            }
            #[doc = "Bit 16 - Digital Comparator Trigger 0"]
            #[inline]
            pub fn dctrig0(&mut self) -> _DCTRIG0W {
                _DCTRIG0W { w: self }
            }
            #[doc = "Bit 17 - Digital Comparator Trigger 1"]
            #[inline]
            pub fn dctrig1(&mut self) -> _DCTRIG1W {
                _DCTRIG1W { w: self }
            }
            #[doc = "Bit 18 - Digital Comparator Trigger 2"]
            #[inline]
            pub fn dctrig2(&mut self) -> _DCTRIG2W {
                _DCTRIG2W { w: self }
            }
            #[doc = "Bit 19 - Digital Comparator Trigger 3"]
            #[inline]
            pub fn dctrig3(&mut self) -> _DCTRIG3W {
                _DCTRIG3W { w: self }
            }
            #[doc = "Bit 20 - Digital Comparator Trigger 4"]
            #[inline]
            pub fn dctrig4(&mut self) -> _DCTRIG4W {
                _DCTRIG4W { w: self }
            }
            #[doc = "Bit 21 - Digital Comparator Trigger 5"]
            #[inline]
            pub fn dctrig5(&mut self) -> _DCTRIG5W {
                _DCTRIG5W { w: self }
            }
            #[doc = "Bit 22 - Digital Comparator Trigger 6"]
            #[inline]
            pub fn dctrig6(&mut self) -> _DCTRIG6W {
                _DCTRIG6W { w: self }
            }
            #[doc = "Bit 23 - Digital Comparator Trigger 7"]
            #[inline]
            pub fn dctrig7(&mut self) -> _DCTRIG7W {
                _DCTRIG7W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 0"]
    pub struct DCCTL0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 0"]
    pub mod dcctl0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 1"]
    pub struct DCCTL1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 1"]
    pub mod dcctl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 2"]
    pub struct DCCTL2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 2"]
    pub mod dcctl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 3"]
    pub struct DCCTL3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 3"]
    pub mod dcctl3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 4"]
    pub struct DCCTL4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 4"]
    pub mod dcctl4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 5"]
    pub struct DCCTL5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 5"]
    pub mod dcctl5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 6"]
    pub struct DCCTL6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 6"]
    pub mod dcctl6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Control 7"]
    pub struct DCCTL7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Control 7"]
    pub mod dcctl7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCTL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CIM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CIMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CIMR::ALWAYS => 0,
                    CIMR::ONCE => 0x01,
                    CIMR::HALWAYS => 0x02,
                    CIMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CIMR {
                match value {
                    0 => CIMR::ALWAYS,
                    1 => CIMR::ONCE,
                    2 => CIMR::HALWAYS,
                    3 => CIMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CIMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CIMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CIMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CIMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CIC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CICR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CICR::LOW => 0,
                    CICR::MID => 0x01,
                    CICR::HIGH => 0x03,
                    CICR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CICR {
                match value {
                    0 => CICR::LOW,
                    1 => CICR::MID,
                    3 => CICR::HIGH,
                    i => CICR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CICR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CICR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CICR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CIER {
            bits: bool,
        }
        impl CIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTMR {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTMR::ALWAYS => 0,
                    CTMR::ONCE => 0x01,
                    CTMR::HALWAYS => 0x02,
                    CTMR::HONCE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTMR {
                match value {
                    0 => CTMR::ALWAYS,
                    1 => CTMR::ONCE,
                    2 => CTMR::HALWAYS,
                    3 => CTMR::HONCE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALWAYS`"]
            #[inline]
            pub fn is_always(&self) -> bool {
                *self == CTMR::ALWAYS
            }
            #[doc = "Checks if the value of the field is `ONCE`"]
            #[inline]
            pub fn is_once(&self) -> bool {
                *self == CTMR::ONCE
            }
            #[doc = "Checks if the value of the field is `HALWAYS`"]
            #[inline]
            pub fn is_halways(&self) -> bool {
                *self == CTMR::HALWAYS
            }
            #[doc = "Checks if the value of the field is `HONCE`"]
            #[inline]
            pub fn is_honce(&self) -> bool {
                *self == CTMR::HONCE
            }
        }
        #[doc = "Possible values of the field `CTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CTCR {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CTCR::LOW => 0,
                    CTCR::MID => 0x01,
                    CTCR::HIGH => 0x03,
                    CTCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CTCR {
                match value {
                    0 => CTCR::LOW,
                    1 => CTCR::MID,
                    3 => CTCR::HIGH,
                    i => CTCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == CTCR::LOW
            }
            #[doc = "Checks if the value of the field is `MID`"]
            #[inline]
            pub fn is_mid(&self) -> bool {
                *self == CTCR::MID
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == CTCR::HIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTER {
            bits: bool,
        }
        impl CTER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `CIM`"]
        pub enum CIMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CIMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CIMW::ALWAYS => 0,
                    CIMW::ONCE => 1,
                    CIMW::HALWAYS => 2,
                    CIMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CIMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CIMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CIMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CIMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CIMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CIC`"]
        pub enum CICW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CICW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CICW::LOW => 0,
                    CICW::MID => 1,
                    CICW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CICW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CICW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CICW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CICW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CICW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CIEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTM`"]
        pub enum CTMW {
            #[doc = "Always"]
            ALWAYS,
            #[doc = "Once"]
            ONCE,
            #[doc = "Hysteresis Always"]
            HALWAYS,
            #[doc = "Hysteresis Once"]
            HONCE,
        }
        impl CTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTMW::ALWAYS => 0,
                    CTMW::ONCE => 1,
                    CTMW::HALWAYS => 2,
                    CTMW::HONCE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Always"]
            #[inline]
            pub fn always(self) -> &'a mut W {
                self.variant(CTMW::ALWAYS)
            }
            #[doc = "Once"]
            #[inline]
            pub fn once(self) -> &'a mut W {
                self.variant(CTMW::ONCE)
            }
            #[doc = "Hysteresis Always"]
            #[inline]
            pub fn halways(self) -> &'a mut W {
                self.variant(CTMW::HALWAYS)
            }
            #[doc = "Hysteresis Once"]
            #[inline]
            pub fn honce(self) -> &'a mut W {
                self.variant(CTMW::HONCE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CTC`"]
        pub enum CTCW {
            #[doc = "Low Band"]
            LOW,
            #[doc = "Mid Band"]
            MID,
            #[doc = "High Band"]
            HIGH,
        }
        impl CTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CTCW::LOW => 0,
                    CTCW::MID => 1,
                    CTCW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CTCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Low Band"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(CTCW::LOW)
            }
            #[doc = "Mid Band"]
            #[inline]
            pub fn mid(self) -> &'a mut W {
                self.variant(CTCW::MID)
            }
            #[doc = "High Band"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(CTCW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CTEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CTEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&self) -> CIMR {
                CIMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&self) -> CICR {
                CICR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&self) -> CIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CIER { bits }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&self) -> CTMR {
                CTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&self) -> CTCR {
                CTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&self) -> CTER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CTER { bits }
            }
        }
        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 0:1 - Comparison Interrupt Mode"]
            #[inline]
            pub fn cim(&mut self) -> _CIMW {
                _CIMW { w: self }
            }
            #[doc = "Bits 2:3 - Comparison Interrupt Condition"]
            #[inline]
            pub fn cic(&mut self) -> _CICW {
                _CICW { w: self }
            }
            #[doc = "Bit 4 - Comparison Interrupt Enable"]
            #[inline]
            pub fn cie(&mut self) -> _CIEW {
                _CIEW { w: self }
            }
            #[doc = "Bits 8:9 - Comparison Trigger Mode"]
            #[inline]
            pub fn ctm(&mut self) -> _CTMW {
                _CTMW { w: self }
            }
            #[doc = "Bits 10:11 - Comparison Trigger Condition"]
            #[inline]
            pub fn ctc(&mut self) -> _CTCW {
                _CTCW { w: self }
            }
            #[doc = "Bit 12 - Comparison Trigger Enable"]
            #[inline]
            pub fn cte(&mut self) -> _CTEW {
                _CTEW { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 0"]
    pub struct DCCMP0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 0"]
    pub mod dccmp0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 1"]
    pub struct DCCMP1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 1"]
    pub mod dccmp1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 2"]
    pub struct DCCMP2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 2"]
    pub mod dccmp2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 3"]
    pub struct DCCMP3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 3"]
    pub mod dccmp3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 4"]
    pub struct DCCMP4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 4"]
    pub mod dccmp4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 5"]
    pub struct DCCMP5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 5"]
    pub mod dccmp5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 6"]
    pub struct DCCMP6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 6"]
    pub mod dccmp6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Digital Comparator Range 7"]
    pub struct DCCMP7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Digital Comparator Range 7"]
    pub mod dccmp7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCCMP7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP0R {
            bits: u16,
        }
        impl COMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMP1R {
            bits: u16,
        }
        impl COMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMP1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x0fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&self) -> COMP0R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP0R { bits }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&self) -> COMP1R {
                let bits = {
                    const MASK: u16 = 0x0fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COMP1R { bits }
            }
        }
        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 0:11 - Compare 0"]
            #[inline]
            pub fn comp0(&mut self) -> _COMP0W {
                _COMP0W { w: self }
            }
            #[doc = "Bits 16:27 - Compare 1"]
            #[inline]
            pub fn comp1(&mut self) -> _COMP1W {
                _COMP1W { w: self }
            }
        }
    }
    #[doc = "ADC Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `MCR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MCRR {
            #[doc = "Full conversion rate (FCONV) as defined by TADC and NSH"]
            FULL,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MCRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MCRR::FULL => 0x07,
                    MCRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MCRR {
                match value {
                    7 => MCRR::FULL,
                    i => MCRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == MCRR::FULL
            }
        }
        #[doc = r" Value of the field"]
        pub struct CHR {
            bits: u8,
        }
        impl CHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCR {
            bits: u8,
        }
        impl DCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `TYPE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TYPER {
            #[doc = "SAR"]
            SAR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TYPER::SAR => 0,
                    TYPER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TYPER {
                match value {
                    0 => TYPER::SAR,
                    i => TYPER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SAR`"]
            #[inline]
            pub fn is_sar(&self) -> bool {
                *self == TYPER::SAR
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSLR {
            bits: u8,
        }
        impl RSLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSR {
            bits: bool,
        }
        impl TSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct APSHTR {
            bits: bool,
        }
        impl APSHTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Maximum Conversion Rate"]
            #[inline]
            pub fn mcr(&self) -> MCRR {
                MCRR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:9 - ADC Channel Count"]
            #[inline]
            pub fn ch(&self) -> CHR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CHR { bits }
            }
            #[doc = "Bits 10:15 - Digital Comparator Count"]
            #[inline]
            pub fn dc(&self) -> DCR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DCR { bits }
            }
            #[doc = "Bits 16:17 - ADC Architecture"]
            #[inline]
            pub fn type_(&self) -> TYPER {
                TYPER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 18:22 - Resolution"]
            #[inline]
            pub fn rsl(&self) -> RSLR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RSLR { bits }
            }
            #[doc = "Bit 23 - Temperature Sensor"]
            #[inline]
            pub fn ts(&self) -> TSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSR { bits }
            }
            #[doc = "Bit 24 - Application-Programmable Sample-and-Hold Time"]
            #[inline]
            pub fn apsht(&self) -> APSHTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                APSHTR { bits }
            }
        }
    }
    #[doc = "ADC Peripheral Configuration"]
    pub struct PC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Peripheral Configuration"]
    pub mod pc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MCR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MCRR {
            #[doc = "Eighth conversion rate. After a conversion completes, the logic pauses for 112 TADC periods before starting the next conversion"]
            _1_8,
            #[doc = "Quarter conversion rate. After a conversion completes, the logic pauses for 48 TADC periods before starting the next conversion"]
            _1_4,
            #[doc = "Half conversion rate. After a conversion completes, the logic pauses for 16 TADC periods before starting the next conversion"]
            _1_2,
            #[doc = "Full conversion rate (FCONV) as defined by TADC and NSH"]
            FULL,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MCRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MCRR::_1_8 => 0x01,
                    MCRR::_1_4 => 0x03,
                    MCRR::_1_2 => 0x05,
                    MCRR::FULL => 0x07,
                    MCRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MCRR {
                match value {
                    1 => MCRR::_1_8,
                    3 => MCRR::_1_4,
                    5 => MCRR::_1_2,
                    7 => MCRR::FULL,
                    i => MCRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1_8`"]
            #[inline]
            pub fn is_1_8(&self) -> bool {
                *self == MCRR::_1_8
            }
            #[doc = "Checks if the value of the field is `_1_4`"]
            #[inline]
            pub fn is_1_4(&self) -> bool {
                *self == MCRR::_1_4
            }
            #[doc = "Checks if the value of the field is `_1_2`"]
            #[inline]
            pub fn is_1_2(&self) -> bool {
                *self == MCRR::_1_2
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == MCRR::FULL
            }
        }
        #[doc = "Values that can be written to the field `MCR`"]
        pub enum MCRW {
            #[doc = "Eighth conversion rate. After a conversion completes, the logic pauses for 112 TADC periods before starting the next conversion"]
            _1_8,
            #[doc = "Quarter conversion rate. After a conversion completes, the logic pauses for 48 TADC periods before starting the next conversion"]
            _1_4,
            #[doc = "Half conversion rate. After a conversion completes, the logic pauses for 16 TADC periods before starting the next conversion"]
            _1_2,
            #[doc = "Full conversion rate (FCONV) as defined by TADC and NSH"]
            FULL,
        }
        impl MCRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MCRW::_1_8 => 1,
                    MCRW::_1_4 => 3,
                    MCRW::_1_2 => 5,
                    MCRW::FULL => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MCRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MCRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MCRW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Eighth conversion rate. After a conversion completes, the logic pauses for 112 TADC periods before starting the next conversion"]
            #[inline]
            pub fn _1_8(self) -> &'a mut W {
                self.variant(MCRW::_1_8)
            }
            #[doc = "Quarter conversion rate. After a conversion completes, the logic pauses for 48 TADC periods before starting the next conversion"]
            #[inline]
            pub fn _1_4(self) -> &'a mut W {
                self.variant(MCRW::_1_4)
            }
            #[doc = "Half conversion rate. After a conversion completes, the logic pauses for 16 TADC periods before starting the next conversion"]
            #[inline]
            pub fn _1_2(self) -> &'a mut W {
                self.variant(MCRW::_1_2)
            }
            #[doc = "Full conversion rate (FCONV) as defined by TADC and NSH"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(MCRW::FULL)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Conversion Rate"]
            #[inline]
            pub fn mcr(&self) -> MCRR {
                MCRR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - Conversion Rate"]
            #[inline]
            pub fn mcr(&mut self) -> _MCRW {
                _MCRW { w: self }
            }
        }
    }
    #[doc = "ADC Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ADC Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CSR {
            #[doc = "PLL VCO divided by CLKDIV"]
            SYSPLL,
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "MOSC"]
            MOSC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CSR::SYSPLL => 0,
                    CSR::PIOSC => 0x01,
                    CSR::MOSC => 0x02,
                    CSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CSR {
                match value {
                    0 => CSR::SYSPLL,
                    1 => CSR::PIOSC,
                    2 => CSR::MOSC,
                    i => CSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSPLL`"]
            #[inline]
            pub fn is_syspll(&self) -> bool {
                *self == CSR::SYSPLL
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == CSR::PIOSC
            }
            #[doc = "Checks if the value of the field is `MOSC`"]
            #[inline]
            pub fn is_mosc(&self) -> bool {
                *self == CSR::MOSC
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKDIVR {
            bits: u8,
        }
        impl CLKDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Values that can be written to the field `CS`"]
        pub enum CSW {
            #[doc = "PLL VCO divided by CLKDIV"]
            SYSPLL,
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "MOSC"]
            MOSC,
        }
        impl CSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CSW::SYSPLL => 0,
                    CSW::PIOSC => 1,
                    CSW::MOSC => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "PLL VCO divided by CLKDIV"]
            #[inline]
            pub fn syspll(self) -> &'a mut W {
                self.variant(CSW::SYSPLL)
            }
            #[doc = "PIOSC"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(CSW::PIOSC)
            }
            #[doc = "MOSC"]
            #[inline]
            pub fn mosc(self) -> &'a mut W {
                self.variant(CSW::MOSC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKDIVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - ADC Clock Source"]
            #[inline]
            pub fn cs(&self) -> CSR {
                CSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:9 - PLL VCO Clock Divisor"]
            #[inline]
            pub fn clkdiv(&self) -> CLKDIVR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CLKDIVR { bits }
            }
        }
        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 0:3 - ADC Clock Source"]
            #[inline]
            pub fn cs(&mut self) -> _CSW {
                _CSW { w: self }
            }
            #[doc = "Bits 4:9 - PLL VCO Clock Divisor"]
            #[inline]
            pub fn clkdiv(&mut self) -> _CLKDIVW {
                _CLKDIVW { w: self }
            }
        }
    }
}
#[doc = "ADC1"]
pub struct ADC1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for ADC1 {}
impl ADC1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const adc0::RegisterBlock {
        0x4003_9000 as *const _
    }
}
impl Deref for ADC1 {
    type Target = adc0::RegisterBlock;
    fn deref(&self) -> &adc0::RegisterBlock {
        unsafe { &*ADC1::ptr() }
    }
}
#[doc = "Comparator register offsets"]
pub struct COMP {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for COMP {}
impl COMP {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const comp::RegisterBlock {
        0x4003_c000 as *const _
    }
}
impl Deref for COMP {
    type Target = comp::RegisterBlock;
    fn deref(&self) -> &comp::RegisterBlock {
        unsafe { &*COMP::ptr() }
    }
}
#[doc = "Comparator register offsets"]
pub mod comp {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Analog Comparator Masked Interrupt Status"]
        pub acmis: ACMIS,
        #[doc = "0x04 - Analog Comparator Raw Interrupt Status"]
        pub acris: ACRIS,
        #[doc = "0x08 - Analog Comparator Interrupt Enable"]
        pub acinten: ACINTEN,
        _reserved0: [u8; 4usize],
        #[doc = "0x10 - Analog Comparator Reference Voltage Control"]
        pub acrefctl: ACREFCTL,
        _reserved1: [u8; 12usize],
        #[doc = "0x20 - Analog Comparator Status 0"]
        pub acstat0: ACSTAT0,
        #[doc = "0x24 - Analog Comparator Control 0"]
        pub acctl0: ACCTL0,
        _reserved2: [u8; 24usize],
        #[doc = "0x40 - Analog Comparator Status 1"]
        pub acstat1: ACSTAT1,
        #[doc = "0x44 - Analog Comparator Control 1"]
        pub acctl1: ACCTL1,
        _reserved3: [u8; 24usize],
        #[doc = "0x60 - Analog Comparator Status 2"]
        pub acstat2: ACSTAT2,
        #[doc = "0x64 - Analog Comparator Control 2"]
        pub acctl2: ACCTL2,
        _reserved4: [u8; 3928usize],
        #[doc = "0xfc0 - Analog Comparator Peripheral Properties"]
        pub pp: PP,
    }
    #[doc = "Analog Comparator Masked Interrupt Status"]
    pub struct ACMIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Masked Interrupt Status"]
    pub mod acmis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACMIS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN0R {
            bits: bool,
        }
        impl IN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN1R {
            bits: bool,
        }
        impl IN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN2R {
            bits: bool,
        }
        impl IN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Comparator 0 Masked Interrupt Status"]
            #[inline]
            pub fn in0(&self) -> IN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN0R { bits }
            }
            #[doc = "Bit 1 - Comparator 1 Masked Interrupt Status"]
            #[inline]
            pub fn in1(&self) -> IN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN1R { bits }
            }
            #[doc = "Bit 2 - Comparator 2 Masked Interrupt Status"]
            #[inline]
            pub fn in2(&self) -> IN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN2R { bits }
            }
        }
        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 = "Bit 0 - Comparator 0 Masked Interrupt Status"]
            #[inline]
            pub fn in0(&mut self) -> _IN0W {
                _IN0W { w: self }
            }
            #[doc = "Bit 1 - Comparator 1 Masked Interrupt Status"]
            #[inline]
            pub fn in1(&mut self) -> _IN1W {
                _IN1W { w: self }
            }
            #[doc = "Bit 2 - Comparator 2 Masked Interrupt Status"]
            #[inline]
            pub fn in2(&mut self) -> _IN2W {
                _IN2W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Raw Interrupt Status"]
    pub struct ACRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Raw Interrupt Status"]
    pub mod acris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ACRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN0R {
            bits: bool,
        }
        impl IN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN1R {
            bits: bool,
        }
        impl IN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN2R {
            bits: bool,
        }
        impl IN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Comparator 0 Interrupt Status"]
            #[inline]
            pub fn in0(&self) -> IN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN0R { bits }
            }
            #[doc = "Bit 1 - Comparator 1 Interrupt Status"]
            #[inline]
            pub fn in1(&self) -> IN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN1R { bits }
            }
            #[doc = "Bit 2 - Comparator 2 Interrupt Status"]
            #[inline]
            pub fn in2(&self) -> IN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN2R { bits }
            }
        }
    }
    #[doc = "Analog Comparator Interrupt Enable"]
    pub struct ACINTEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Interrupt Enable"]
    pub mod acinten {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACINTEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN0R {
            bits: bool,
        }
        impl IN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN1R {
            bits: bool,
        }
        impl IN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IN2R {
            bits: bool,
        }
        impl IN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _IN2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Comparator 0 Interrupt Enable"]
            #[inline]
            pub fn in0(&self) -> IN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN0R { bits }
            }
            #[doc = "Bit 1 - Comparator 1 Interrupt Enable"]
            #[inline]
            pub fn in1(&self) -> IN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN1R { bits }
            }
            #[doc = "Bit 2 - Comparator 2 Interrupt Enable"]
            #[inline]
            pub fn in2(&self) -> IN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IN2R { bits }
            }
        }
        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 = "Bit 0 - Comparator 0 Interrupt Enable"]
            #[inline]
            pub fn in0(&mut self) -> _IN0W {
                _IN0W { w: self }
            }
            #[doc = "Bit 1 - Comparator 1 Interrupt Enable"]
            #[inline]
            pub fn in1(&mut self) -> _IN1W {
                _IN1W { w: self }
            }
            #[doc = "Bit 2 - Comparator 2 Interrupt Enable"]
            #[inline]
            pub fn in2(&mut self) -> _IN2W {
                _IN2W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Reference Voltage Control"]
    pub struct ACREFCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Reference Voltage Control"]
    pub mod acrefctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACREFCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VREFR {
            bits: u8,
        }
        impl VREFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RNGR {
            bits: bool,
        }
        impl RNGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENR {
            bits: bool,
        }
        impl ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VREFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VREFW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RNGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RNGW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Resistor Ladder Voltage Ref"]
            #[inline]
            pub fn vref(&self) -> VREFR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                VREFR { bits }
            }
            #[doc = "Bit 8 - Resistor Ladder Range"]
            #[inline]
            pub fn rng(&self) -> RNGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RNGR { bits }
            }
            #[doc = "Bit 9 - Resistor Ladder Enable"]
            #[inline]
            pub fn en(&self) -> ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENR { bits }
            }
        }
        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 0:3 - Resistor Ladder Voltage Ref"]
            #[inline]
            pub fn vref(&mut self) -> _VREFW {
                _VREFW { w: self }
            }
            #[doc = "Bit 8 - Resistor Ladder Range"]
            #[inline]
            pub fn rng(&mut self) -> _RNGW {
                _RNGW { w: self }
            }
            #[doc = "Bit 9 - Resistor Ladder Enable"]
            #[inline]
            pub fn en(&mut self) -> _ENW {
                _ENW { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Status 0"]
    pub struct ACSTAT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Status 0"]
    pub mod acstat0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ACSTAT0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVALR {
            bits: bool,
        }
        impl OVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Value"]
            #[inline]
            pub fn oval(&self) -> OVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVALR { bits }
            }
        }
    }
    #[doc = "Analog Comparator Control 0"]
    pub struct ACCTL0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Control 0"]
    pub mod acctl0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACCTL0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CINVR {
            bits: bool,
        }
        impl CINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ISEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ISENR {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ISENR::LEVEL => 0,
                    ISENR::FALL => 0x01,
                    ISENR::RISE => 0x02,
                    ISENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ISENR {
                match value {
                    0 => ISENR::LEVEL,
                    1 => ISENR::FALL,
                    2 => ISENR::RISE,
                    3 => ISENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == ISENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == ISENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == ISENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == ISENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISLVALR {
            bits: bool,
        }
        impl ISLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TSEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSENR {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSENR::LEVEL => 0,
                    TSENR::FALL => 0x01,
                    TSENR::RISE => 0x02,
                    TSENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSENR {
                match value {
                    0 => TSENR::LEVEL,
                    1 => TSENR::FALL,
                    2 => TSENR::RISE,
                    3 => TSENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == TSENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == TSENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == TSENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == TSENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSLVALR {
            bits: bool,
        }
        impl TSLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ASRCP`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ASRCPR {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ASRCPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ASRCPR::PIN => 0,
                    ASRCPR::PIN0 => 0x01,
                    ASRCPR::REF => 0x02,
                    ASRCPR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ASRCPR {
                match value {
                    0 => ASRCPR::PIN,
                    1 => ASRCPR::PIN0,
                    2 => ASRCPR::REF,
                    i => ASRCPR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIN`"]
            #[inline]
            pub fn is_pin(&self) -> bool {
                *self == ASRCPR::PIN
            }
            #[doc = "Checks if the value of the field is `PIN0`"]
            #[inline]
            pub fn is_pin0(&self) -> bool {
                *self == ASRCPR::PIN0
            }
            #[doc = "Checks if the value of the field is `REF`"]
            #[inline]
            pub fn is_ref_(&self) -> bool {
                *self == ASRCPR::REF
            }
        }
        #[doc = r" Value of the field"]
        pub struct TOENR {
            bits: bool,
        }
        impl TOENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CINVW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ISEN`"]
        pub enum ISENW {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ISENW::LEVEL => 0,
                    ISENW::FALL => 1,
                    ISENW::RISE => 2,
                    ISENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ISENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see ISLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(ISENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(ISENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(ISENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(ISENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISLVALW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSEN`"]
        pub enum TSENW {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSENW::LEVEL => 0,
                    TSENW::FALL => 1,
                    TSENW::RISE => 2,
                    TSENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see TSLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(TSENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(TSENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(TSENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(TSENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _TSLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSLVALW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ASRCP`"]
        pub enum ASRCPW {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
        }
        impl ASRCPW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ASRCPW::PIN => 0,
                    ASRCPW::PIN0 => 1,
                    ASRCPW::REF => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASRCPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASRCPW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ASRCPW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Pin value of Cn+"]
            #[inline]
            pub fn pin(self) -> &'a mut W {
                self.variant(ASRCPW::PIN)
            }
            #[doc = "Pin value of C0+"]
            #[inline]
            pub fn pin0(self) -> &'a mut W {
                self.variant(ASRCPW::PIN0)
            }
            #[doc = "Internal voltage reference"]
            #[inline]
            pub fn ref_(self) -> &'a mut W {
                self.variant(ASRCPW::REF)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TOENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TOENW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&self) -> CINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CINVR { bits }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&self) -> ISENR {
                ISENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&self) -> ISLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ISLVALR { bits }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&self) -> TSENR {
                TSENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&self) -> TSLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSLVALR { bits }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&self) -> ASRCPR {
                ASRCPR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&self) -> TOENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TOENR { bits }
            }
        }
        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 = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&mut self) -> _CINVW {
                _CINVW { w: self }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&mut self) -> _ISENW {
                _ISENW { w: self }
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&mut self) -> _ISLVALW {
                _ISLVALW { w: self }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&mut self) -> _TSENW {
                _TSENW { w: self }
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&mut self) -> _TSLVALW {
                _TSLVALW { w: self }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&mut self) -> _ASRCPW {
                _ASRCPW { w: self }
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&mut self) -> _TOENW {
                _TOENW { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Status 1"]
    pub struct ACSTAT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Status 1"]
    pub mod acstat1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ACSTAT1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVALR {
            bits: bool,
        }
        impl OVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Value"]
            #[inline]
            pub fn oval(&self) -> OVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVALR { bits }
            }
        }
    }
    #[doc = "Analog Comparator Control 1"]
    pub struct ACCTL1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Control 1"]
    pub mod acctl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACCTL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CINVR {
            bits: bool,
        }
        impl CINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ISEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ISENR {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ISENR::LEVEL => 0,
                    ISENR::FALL => 0x01,
                    ISENR::RISE => 0x02,
                    ISENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ISENR {
                match value {
                    0 => ISENR::LEVEL,
                    1 => ISENR::FALL,
                    2 => ISENR::RISE,
                    3 => ISENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == ISENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == ISENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == ISENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == ISENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISLVALR {
            bits: bool,
        }
        impl ISLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TSEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSENR {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSENR::LEVEL => 0,
                    TSENR::FALL => 0x01,
                    TSENR::RISE => 0x02,
                    TSENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSENR {
                match value {
                    0 => TSENR::LEVEL,
                    1 => TSENR::FALL,
                    2 => TSENR::RISE,
                    3 => TSENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == TSENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == TSENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == TSENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == TSENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSLVALR {
            bits: bool,
        }
        impl TSLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ASRCP`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ASRCPR {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ASRCPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ASRCPR::PIN => 0,
                    ASRCPR::PIN0 => 0x01,
                    ASRCPR::REF => 0x02,
                    ASRCPR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ASRCPR {
                match value {
                    0 => ASRCPR::PIN,
                    1 => ASRCPR::PIN0,
                    2 => ASRCPR::REF,
                    i => ASRCPR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIN`"]
            #[inline]
            pub fn is_pin(&self) -> bool {
                *self == ASRCPR::PIN
            }
            #[doc = "Checks if the value of the field is `PIN0`"]
            #[inline]
            pub fn is_pin0(&self) -> bool {
                *self == ASRCPR::PIN0
            }
            #[doc = "Checks if the value of the field is `REF`"]
            #[inline]
            pub fn is_ref_(&self) -> bool {
                *self == ASRCPR::REF
            }
        }
        #[doc = r" Value of the field"]
        pub struct TOENR {
            bits: bool,
        }
        impl TOENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CINVW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ISEN`"]
        pub enum ISENW {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ISENW::LEVEL => 0,
                    ISENW::FALL => 1,
                    ISENW::RISE => 2,
                    ISENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ISENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see ISLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(ISENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(ISENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(ISENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(ISENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISLVALW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSEN`"]
        pub enum TSENW {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSENW::LEVEL => 0,
                    TSENW::FALL => 1,
                    TSENW::RISE => 2,
                    TSENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see TSLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(TSENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(TSENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(TSENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(TSENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _TSLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSLVALW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ASRCP`"]
        pub enum ASRCPW {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
        }
        impl ASRCPW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ASRCPW::PIN => 0,
                    ASRCPW::PIN0 => 1,
                    ASRCPW::REF => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASRCPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASRCPW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ASRCPW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Pin value of Cn+"]
            #[inline]
            pub fn pin(self) -> &'a mut W {
                self.variant(ASRCPW::PIN)
            }
            #[doc = "Pin value of C0+"]
            #[inline]
            pub fn pin0(self) -> &'a mut W {
                self.variant(ASRCPW::PIN0)
            }
            #[doc = "Internal voltage reference"]
            #[inline]
            pub fn ref_(self) -> &'a mut W {
                self.variant(ASRCPW::REF)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TOENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TOENW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&self) -> CINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CINVR { bits }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&self) -> ISENR {
                ISENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&self) -> ISLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ISLVALR { bits }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&self) -> TSENR {
                TSENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&self) -> TSLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSLVALR { bits }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&self) -> ASRCPR {
                ASRCPR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&self) -> TOENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TOENR { bits }
            }
        }
        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 = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&mut self) -> _CINVW {
                _CINVW { w: self }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&mut self) -> _ISENW {
                _ISENW { w: self }
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&mut self) -> _ISLVALW {
                _ISLVALW { w: self }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&mut self) -> _TSENW {
                _TSENW { w: self }
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&mut self) -> _TSLVALW {
                _TSLVALW { w: self }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&mut self) -> _ASRCPW {
                _ASRCPW { w: self }
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&mut self) -> _TOENW {
                _TOENW { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Status 2"]
    pub struct ACSTAT2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Status 2"]
    pub mod acstat2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ACSTAT2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVALR {
            bits: bool,
        }
        impl OVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Value"]
            #[inline]
            pub fn oval(&self) -> OVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVALR { bits }
            }
        }
    }
    #[doc = "Analog Comparator Control 2"]
    pub struct ACCTL2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Control 2"]
    pub mod acctl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ACCTL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CINVR {
            bits: bool,
        }
        impl CINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ISEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ISENR {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ISENR::LEVEL => 0,
                    ISENR::FALL => 0x01,
                    ISENR::RISE => 0x02,
                    ISENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ISENR {
                match value {
                    0 => ISENR::LEVEL,
                    1 => ISENR::FALL,
                    2 => ISENR::RISE,
                    3 => ISENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == ISENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == ISENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == ISENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == ISENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISLVALR {
            bits: bool,
        }
        impl ISLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TSEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSENR {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSENR::LEVEL => 0,
                    TSENR::FALL => 0x01,
                    TSENR::RISE => 0x02,
                    TSENR::BOTH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSENR {
                match value {
                    0 => TSENR::LEVEL,
                    1 => TSENR::FALL,
                    2 => TSENR::RISE,
                    3 => TSENR::BOTH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LEVEL`"]
            #[inline]
            pub fn is_level(&self) -> bool {
                *self == TSENR::LEVEL
            }
            #[doc = "Checks if the value of the field is `FALL`"]
            #[inline]
            pub fn is_fall(&self) -> bool {
                *self == TSENR::FALL
            }
            #[doc = "Checks if the value of the field is `RISE`"]
            #[inline]
            pub fn is_rise(&self) -> bool {
                *self == TSENR::RISE
            }
            #[doc = "Checks if the value of the field is `BOTH`"]
            #[inline]
            pub fn is_both(&self) -> bool {
                *self == TSENR::BOTH
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSLVALR {
            bits: bool,
        }
        impl TSLVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ASRCP`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ASRCPR {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ASRCPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ASRCPR::PIN => 0,
                    ASRCPR::PIN0 => 0x01,
                    ASRCPR::REF => 0x02,
                    ASRCPR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ASRCPR {
                match value {
                    0 => ASRCPR::PIN,
                    1 => ASRCPR::PIN0,
                    2 => ASRCPR::REF,
                    i => ASRCPR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIN`"]
            #[inline]
            pub fn is_pin(&self) -> bool {
                *self == ASRCPR::PIN
            }
            #[doc = "Checks if the value of the field is `PIN0`"]
            #[inline]
            pub fn is_pin0(&self) -> bool {
                *self == ASRCPR::PIN0
            }
            #[doc = "Checks if the value of the field is `REF`"]
            #[inline]
            pub fn is_ref_(&self) -> bool {
                *self == ASRCPR::REF
            }
        }
        #[doc = r" Value of the field"]
        pub struct TOENR {
            bits: bool,
        }
        impl TOENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CINVW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ISEN`"]
        pub enum ISENW {
            #[doc = "Level sense, see ISLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl ISENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ISENW::LEVEL => 0,
                    ISENW::FALL => 1,
                    ISENW::RISE => 2,
                    ISENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ISENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see ISLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(ISENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(ISENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(ISENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(ISENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISLVALW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TSEN`"]
        pub enum TSENW {
            #[doc = "Level sense, see TSLVAL"]
            LEVEL,
            #[doc = "Falling edge"]
            FALL,
            #[doc = "Rising edge"]
            RISE,
            #[doc = "Either edge"]
            BOTH,
        }
        impl TSENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSENW::LEVEL => 0,
                    TSENW::FALL => 1,
                    TSENW::RISE => 2,
                    TSENW::BOTH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Level sense, see TSLVAL"]
            #[inline]
            pub fn level(self) -> &'a mut W {
                self.variant(TSENW::LEVEL)
            }
            #[doc = "Falling edge"]
            #[inline]
            pub fn fall(self) -> &'a mut W {
                self.variant(TSENW::FALL)
            }
            #[doc = "Rising edge"]
            #[inline]
            pub fn rise(self) -> &'a mut W {
                self.variant(TSENW::RISE)
            }
            #[doc = "Either edge"]
            #[inline]
            pub fn both(self) -> &'a mut W {
                self.variant(TSENW::BOTH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _TSLVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSLVALW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ASRCP`"]
        pub enum ASRCPW {
            #[doc = "Pin value of Cn+"]
            PIN,
            #[doc = "Pin value of C0+"]
            PIN0,
            #[doc = "Internal voltage reference"]
            REF,
        }
        impl ASRCPW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ASRCPW::PIN => 0,
                    ASRCPW::PIN0 => 1,
                    ASRCPW::REF => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASRCPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASRCPW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ASRCPW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Pin value of Cn+"]
            #[inline]
            pub fn pin(self) -> &'a mut W {
                self.variant(ASRCPW::PIN)
            }
            #[doc = "Pin value of C0+"]
            #[inline]
            pub fn pin0(self) -> &'a mut W {
                self.variant(ASRCPW::PIN0)
            }
            #[doc = "Internal voltage reference"]
            #[inline]
            pub fn ref_(self) -> &'a mut W {
                self.variant(ASRCPW::REF)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TOENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TOENW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&self) -> CINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CINVR { bits }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&self) -> ISENR {
                ISENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&self) -> ISLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ISLVALR { bits }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&self) -> TSENR {
                TSENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&self) -> TSLVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSLVALR { bits }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&self) -> ASRCPR {
                ASRCPR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&self) -> TOENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TOENR { bits }
            }
        }
        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 = "Bit 1 - Comparator Output Invert"]
            #[inline]
            pub fn cinv(&mut self) -> _CINVW {
                _CINVW { w: self }
            }
            #[doc = "Bits 2:3 - Interrupt Sense"]
            #[inline]
            pub fn isen(&mut self) -> _ISENW {
                _ISENW { w: self }
            }
            #[doc = "Bit 4 - Interrupt Sense Level Value"]
            #[inline]
            pub fn islval(&mut self) -> _ISLVALW {
                _ISLVALW { w: self }
            }
            #[doc = "Bits 5:6 - Trigger Sense"]
            #[inline]
            pub fn tsen(&mut self) -> _TSENW {
                _TSENW { w: self }
            }
            #[doc = "Bit 7 - Trigger Sense Level Value"]
            #[inline]
            pub fn tslval(&mut self) -> _TSLVALW {
                _TSLVALW { w: self }
            }
            #[doc = "Bits 9:10 - Analog Source Positive"]
            #[inline]
            pub fn asrcp(&mut self) -> _ASRCPW {
                _ASRCPW { w: self }
            }
            #[doc = "Bit 11 - Trigger Output Enable"]
            #[inline]
            pub fn toen(&mut self) -> _TOENW {
                _TOENW { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMP0R {
            bits: bool,
        }
        impl CMP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMP1R {
            bits: bool,
        }
        impl CMP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CMP2R {
            bits: bool,
        }
        impl CMP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct C0OR {
            bits: bool,
        }
        impl C0OR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct C1OR {
            bits: bool,
        }
        impl C1OR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct C2OR {
            bits: bool,
        }
        impl C2OR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Comparator 0 Present"]
            #[inline]
            pub fn cmp0(&self) -> CMP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMP0R { bits }
            }
            #[doc = "Bit 1 - Comparator 1 Present"]
            #[inline]
            pub fn cmp1(&self) -> CMP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMP1R { bits }
            }
            #[doc = "Bit 2 - Comparator 2 Present"]
            #[inline]
            pub fn cmp2(&self) -> CMP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CMP2R { bits }
            }
            #[doc = "Bit 16 - Comparator Output 0 Present"]
            #[inline]
            pub fn c0o(&self) -> C0OR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                C0OR { bits }
            }
            #[doc = "Bit 17 - Comparator Output 1 Present"]
            #[inline]
            pub fn c1o(&self) -> C1OR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                C1OR { bits }
            }
            #[doc = "Bit 18 - Comparator Output 2 Present"]
            #[inline]
            pub fn c2o(&self) -> C2OR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                C2OR { bits }
            }
        }
    }
}
#[doc = "CAN register offsets"]
pub struct CAN0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN0 {}
impl CAN0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const can0::RegisterBlock {
        0x4004_0000 as *const _
    }
}
impl Deref for CAN0 {
    type Target = can0::RegisterBlock;
    fn deref(&self) -> &can0::RegisterBlock {
        unsafe { &*CAN0::ptr() }
    }
}
#[doc = "CAN register offsets"]
pub mod can0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - CAN Control"]
        pub ctl: CTL,
        #[doc = "0x04 - CAN Status"]
        pub sts: STS,
        #[doc = "0x08 - CAN Error Counter"]
        pub err: ERR,
        #[doc = "0x0c - CAN Bit Timing"]
        pub bit_: BIT,
        #[doc = "0x10 - CAN Interrupt"]
        pub int: INT,
        #[doc = "0x14 - CAN Test"]
        pub tst: TST,
        #[doc = "0x18 - CAN Baud Rate Prescaler Extension"]
        pub brpe: BRPE,
        _reserved0: [u8; 4usize],
        #[doc = "0x20 - CAN IF1 Command Request"]
        pub if1crq: IF1CRQ,
        #[doc = "0x24 - CAN IF1 Command Mask"]
        pub if1cmsk: IF1CMSK,
        #[doc = "0x28 - CAN IF1 Mask 1"]
        pub if1msk1: IF1MSK1,
        #[doc = "0x2c - CAN IF1 Mask 2"]
        pub if1msk2: IF1MSK2,
        #[doc = "0x30 - CAN IF1 Arbitration 1"]
        pub if1arb1: IF1ARB1,
        #[doc = "0x34 - CAN IF1 Arbitration 2"]
        pub if1arb2: IF1ARB2,
        #[doc = "0x38 - CAN IF1 Message Control"]
        pub if1mctl: IF1MCTL,
        #[doc = "0x3c - CAN IF1 Data A1"]
        pub if1da1: IF1DA1,
        #[doc = "0x40 - CAN IF1 Data A2"]
        pub if1da2: IF1DA2,
        #[doc = "0x44 - CAN IF1 Data B1"]
        pub if1db1: IF1DB1,
        #[doc = "0x48 - CAN IF1 Data B2"]
        pub if1db2: IF1DB2,
        _reserved1: [u8; 52usize],
        #[doc = "0x80 - CAN IF2 Command Request"]
        pub if2crq: IF2CRQ,
        #[doc = "0x84 - CAN IF2 Command Mask"]
        pub if2cmsk: IF2CMSK,
        #[doc = "0x88 - CAN IF2 Mask 1"]
        pub if2msk1: IF2MSK1,
        #[doc = "0x8c - CAN IF2 Mask 2"]
        pub if2msk2: IF2MSK2,
        #[doc = "0x90 - CAN IF2 Arbitration 1"]
        pub if2arb1: IF2ARB1,
        #[doc = "0x94 - CAN IF2 Arbitration 2"]
        pub if2arb2: IF2ARB2,
        #[doc = "0x98 - CAN IF2 Message Control"]
        pub if2mctl: IF2MCTL,
        #[doc = "0x9c - CAN IF2 Data A1"]
        pub if2da1: IF2DA1,
        #[doc = "0xa0 - CAN IF2 Data A2"]
        pub if2da2: IF2DA2,
        #[doc = "0xa4 - CAN IF2 Data B1"]
        pub if2db1: IF2DB1,
        #[doc = "0xa8 - CAN IF2 Data B2"]
        pub if2db2: IF2DB2,
        _reserved2: [u8; 84usize],
        #[doc = "0x100 - CAN Transmission Request 1"]
        pub txrq1: TXRQ1,
        #[doc = "0x104 - CAN Transmission Request 2"]
        pub txrq2: TXRQ2,
        _reserved3: [u8; 24usize],
        #[doc = "0x120 - CAN New Data 1"]
        pub nwda1: NWDA1,
        #[doc = "0x124 - CAN New Data 2"]
        pub nwda2: NWDA2,
        _reserved4: [u8; 24usize],
        #[doc = "0x140 - CAN Message 1 Interrupt Pending"]
        pub msg1int: MSG1INT,
        #[doc = "0x144 - CAN Message 2 Interrupt Pending"]
        pub msg2int: MSG2INT,
        _reserved5: [u8; 24usize],
        #[doc = "0x160 - CAN Message 1 Valid"]
        pub msg1val: MSG1VAL,
        #[doc = "0x164 - CAN Message 2 Valid"]
        pub msg2val: MSG2VAL,
    }
    #[doc = "CAN Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INITR {
            bits: bool,
        }
        impl INITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIER {
            bits: bool,
        }
        impl SIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EIER {
            bits: bool,
        }
        impl EIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DARR {
            bits: bool,
        }
        impl DARR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CCER {
            bits: bool,
        }
        impl CCER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TESTR {
            bits: bool,
        }
        impl TESTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INITW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EIEW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DARW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DARW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CCEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CCEW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TESTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TESTW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Initialization"]
            #[inline]
            pub fn init(&self) -> INITR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INITR { bits }
            }
            #[doc = "Bit 1 - CAN Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IER { bits }
            }
            #[doc = "Bit 2 - Status Interrupt Enable"]
            #[inline]
            pub fn sie(&self) -> SIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SIER { bits }
            }
            #[doc = "Bit 3 - Error Interrupt Enable"]
            #[inline]
            pub fn eie(&self) -> EIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EIER { bits }
            }
            #[doc = "Bit 5 - Disable Automatic-Retransmission"]
            #[inline]
            pub fn dar(&self) -> DARR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DARR { bits }
            }
            #[doc = "Bit 6 - Configuration Change Enable"]
            #[inline]
            pub fn cce(&self) -> CCER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CCER { bits }
            }
            #[doc = "Bit 7 - Test Mode Enable"]
            #[inline]
            pub fn test(&self) -> TESTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TESTR { bits }
            }
        }
        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 = "Bit 0 - Initialization"]
            #[inline]
            pub fn init(&mut self) -> _INITW {
                _INITW { w: self }
            }
            #[doc = "Bit 1 - CAN Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bit 2 - Status Interrupt Enable"]
            #[inline]
            pub fn sie(&mut self) -> _SIEW {
                _SIEW { w: self }
            }
            #[doc = "Bit 3 - Error Interrupt Enable"]
            #[inline]
            pub fn eie(&mut self) -> _EIEW {
                _EIEW { w: self }
            }
            #[doc = "Bit 5 - Disable Automatic-Retransmission"]
            #[inline]
            pub fn dar(&mut self) -> _DARW {
                _DARW { w: self }
            }
            #[doc = "Bit 6 - Configuration Change Enable"]
            #[inline]
            pub fn cce(&mut self) -> _CCEW {
                _CCEW { w: self }
            }
            #[doc = "Bit 7 - Test Mode Enable"]
            #[inline]
            pub fn test(&mut self) -> _TESTW {
                _TESTW { w: self }
            }
        }
    }
    #[doc = "CAN Status"]
    pub struct STS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Status"]
    pub mod sts {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::STS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `LEC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum LECR {
            #[doc = "No Error"]
            NONE,
            #[doc = "Stuff Error"]
            STUFF,
            #[doc = "Format Error"]
            FORM,
            #[doc = "ACK Error"]
            ACK,
            #[doc = "Bit 1 Error"]
            BIT1,
            #[doc = "Bit 0 Error"]
            BIT0,
            #[doc = "CRC Error"]
            CRC,
            #[doc = "No Event"]
            NOEVENT,
        }
        impl LECR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    LECR::NONE => 0,
                    LECR::STUFF => 0x01,
                    LECR::FORM => 0x02,
                    LECR::ACK => 0x03,
                    LECR::BIT1 => 0x04,
                    LECR::BIT0 => 0x05,
                    LECR::CRC => 0x06,
                    LECR::NOEVENT => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> LECR {
                match value {
                    0 => LECR::NONE,
                    1 => LECR::STUFF,
                    2 => LECR::FORM,
                    3 => LECR::ACK,
                    4 => LECR::BIT1,
                    5 => LECR::BIT0,
                    6 => LECR::CRC,
                    7 => LECR::NOEVENT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == LECR::NONE
            }
            #[doc = "Checks if the value of the field is `STUFF`"]
            #[inline]
            pub fn is_stuff(&self) -> bool {
                *self == LECR::STUFF
            }
            #[doc = "Checks if the value of the field is `FORM`"]
            #[inline]
            pub fn is_form(&self) -> bool {
                *self == LECR::FORM
            }
            #[doc = "Checks if the value of the field is `ACK`"]
            #[inline]
            pub fn is_ack(&self) -> bool {
                *self == LECR::ACK
            }
            #[doc = "Checks if the value of the field is `BIT1`"]
            #[inline]
            pub fn is_bit1(&self) -> bool {
                *self == LECR::BIT1
            }
            #[doc = "Checks if the value of the field is `BIT0`"]
            #[inline]
            pub fn is_bit0(&self) -> bool {
                *self == LECR::BIT0
            }
            #[doc = "Checks if the value of the field is `CRC`"]
            #[inline]
            pub fn is_crc(&self) -> bool {
                *self == LECR::CRC
            }
            #[doc = "Checks if the value of the field is `NOEVENT`"]
            #[inline]
            pub fn is_noevent(&self) -> bool {
                *self == LECR::NOEVENT
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXOKR {
            bits: bool,
        }
        impl TXOKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXOKR {
            bits: bool,
        }
        impl RXOKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPASSR {
            bits: bool,
        }
        impl EPASSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EWARNR {
            bits: bool,
        }
        impl EWARNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BOFFR {
            bits: bool,
        }
        impl BOFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `LEC`"]
        pub enum LECW {
            #[doc = "No Error"]
            NONE,
            #[doc = "Stuff Error"]
            STUFF,
            #[doc = "Format Error"]
            FORM,
            #[doc = "ACK Error"]
            ACK,
            #[doc = "Bit 1 Error"]
            BIT1,
            #[doc = "Bit 0 Error"]
            BIT0,
            #[doc = "CRC Error"]
            CRC,
            #[doc = "No Event"]
            NOEVENT,
        }
        impl LECW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    LECW::NONE => 0,
                    LECW::STUFF => 1,
                    LECW::FORM => 2,
                    LECW::ACK => 3,
                    LECW::BIT1 => 4,
                    LECW::BIT0 => 5,
                    LECW::CRC => 6,
                    LECW::NOEVENT => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _LECW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LECW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: LECW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No Error"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(LECW::NONE)
            }
            #[doc = "Stuff Error"]
            #[inline]
            pub fn stuff(self) -> &'a mut W {
                self.variant(LECW::STUFF)
            }
            #[doc = "Format Error"]
            #[inline]
            pub fn form(self) -> &'a mut W {
                self.variant(LECW::FORM)
            }
            #[doc = "ACK Error"]
            #[inline]
            pub fn ack(self) -> &'a mut W {
                self.variant(LECW::ACK)
            }
            #[doc = "Bit 1 Error"]
            #[inline]
            pub fn bit1(self) -> &'a mut W {
                self.variant(LECW::BIT1)
            }
            #[doc = "Bit 0 Error"]
            #[inline]
            pub fn bit0(self) -> &'a mut W {
                self.variant(LECW::BIT0)
            }
            #[doc = "CRC Error"]
            #[inline]
            pub fn crc(self) -> &'a mut W {
                self.variant(LECW::CRC)
            }
            #[doc = "No Event"]
            #[inline]
            pub fn noevent(self) -> &'a mut W {
                self.variant(LECW::NOEVENT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXOKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXOKW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXOKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXOKW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPASSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPASSW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EWARNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EWARNW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BOFFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BOFFW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Last Error Code"]
            #[inline]
            pub fn lec(&self) -> LECR {
                LECR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 3 - Transmitted a Message Successfully"]
            #[inline]
            pub fn txok(&self) -> TXOKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXOKR { bits }
            }
            #[doc = "Bit 4 - Received a Message Successfully"]
            #[inline]
            pub fn rxok(&self) -> RXOKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXOKR { bits }
            }
            #[doc = "Bit 5 - Error Passive"]
            #[inline]
            pub fn epass(&self) -> EPASSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EPASSR { bits }
            }
            #[doc = "Bit 6 - Warning Status"]
            #[inline]
            pub fn ewarn(&self) -> EWARNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EWARNR { bits }
            }
            #[doc = "Bit 7 - Bus-Off Status"]
            #[inline]
            pub fn boff(&self) -> BOFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BOFFR { bits }
            }
        }
        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 0:2 - Last Error Code"]
            #[inline]
            pub fn lec(&mut self) -> _LECW {
                _LECW { w: self }
            }
            #[doc = "Bit 3 - Transmitted a Message Successfully"]
            #[inline]
            pub fn txok(&mut self) -> _TXOKW {
                _TXOKW { w: self }
            }
            #[doc = "Bit 4 - Received a Message Successfully"]
            #[inline]
            pub fn rxok(&mut self) -> _RXOKW {
                _RXOKW { w: self }
            }
            #[doc = "Bit 5 - Error Passive"]
            #[inline]
            pub fn epass(&mut self) -> _EPASSW {
                _EPASSW { w: self }
            }
            #[doc = "Bit 6 - Warning Status"]
            #[inline]
            pub fn ewarn(&mut self) -> _EWARNW {
                _EWARNW { w: self }
            }
            #[doc = "Bit 7 - Bus-Off Status"]
            #[inline]
            pub fn boff(&mut self) -> _BOFFW {
                _BOFFW { w: self }
            }
        }
    }
    #[doc = "CAN Error Counter"]
    pub struct ERR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Error Counter"]
    pub mod err {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ERR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TECR {
            bits: u8,
        }
        impl TECR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RECR {
            bits: u8,
        }
        impl RECR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RPR {
            bits: bool,
        }
        impl RPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Transmit Error Counter"]
            #[inline]
            pub fn tec(&self) -> TECR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TECR { bits }
            }
            #[doc = "Bits 8:14 - Receive Error Counter"]
            #[inline]
            pub fn rec(&self) -> RECR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RECR { bits }
            }
            #[doc = "Bit 15 - Received Error Passive"]
            #[inline]
            pub fn rp(&self) -> RPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RPR { bits }
            }
        }
    }
    #[doc = "CAN Bit Timing"]
    pub struct BIT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Bit Timing"]
    pub mod bit_ {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::BIT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BRPR {
            bits: u8,
        }
        impl BRPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SJWR {
            bits: u8,
        }
        impl SJWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSEG1R {
            bits: u8,
        }
        impl TSEG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSEG2R {
            bits: u8,
        }
        impl TSEG2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SJWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SJWW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSEG1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSEG1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _TSEG2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSEG2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Baud Rate Prescaler"]
            #[inline]
            pub fn brp(&self) -> BRPR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                BRPR { bits }
            }
            #[doc = "Bits 6:7 - (Re)Synchronization Jump Width"]
            #[inline]
            pub fn sjw(&self) -> SJWR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SJWR { bits }
            }
            #[doc = "Bits 8:11 - Time Segment Before Sample Point"]
            #[inline]
            pub fn tseg1(&self) -> TSEG1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSEG1R { bits }
            }
            #[doc = "Bits 12:14 - Time Segment after Sample Point"]
            #[inline]
            pub fn tseg2(&self) -> TSEG2R {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                TSEG2R { bits }
            }
        }
        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 0:5 - Baud Rate Prescaler"]
            #[inline]
            pub fn brp(&mut self) -> _BRPW {
                _BRPW { w: self }
            }
            #[doc = "Bits 6:7 - (Re)Synchronization Jump Width"]
            #[inline]
            pub fn sjw(&mut self) -> _SJWW {
                _SJWW { w: self }
            }
            #[doc = "Bits 8:11 - Time Segment Before Sample Point"]
            #[inline]
            pub fn tseg1(&mut self) -> _TSEG1W {
                _TSEG1W { w: self }
            }
            #[doc = "Bits 12:14 - Time Segment after Sample Point"]
            #[inline]
            pub fn tseg2(&mut self) -> _TSEG2W {
                _TSEG2W { w: self }
            }
        }
    }
    #[doc = "CAN Interrupt"]
    pub struct INT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Interrupt"]
    pub mod int {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::INT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `INTID`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum INTIDR {
            #[doc = "No interrupt pending"]
            NONE,
            #[doc = "Status Interrupt"]
            STATUS,
            #[doc = r" Reserved"]
            _Reserved(u16),
        }
        impl INTIDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                match *self {
                    INTIDR::NONE => 0,
                    INTIDR::STATUS => 0x8000,
                    INTIDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u16) -> INTIDR {
                match value {
                    0 => INTIDR::NONE,
                    32768 => INTIDR::STATUS,
                    i => INTIDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == INTIDR::NONE
            }
            #[doc = "Checks if the value of the field is `STATUS`"]
            #[inline]
            pub fn is_status(&self) -> bool {
                *self == INTIDR::STATUS
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Interrupt Identifier"]
            #[inline]
            pub fn intid(&self) -> INTIDR {
                INTIDR::_from({
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                })
            }
        }
    }
    #[doc = "CAN Test"]
    pub struct TST {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Test"]
    pub mod tst {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TST {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BASICR {
            bits: bool,
        }
        impl BASICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SILENTR {
            bits: bool,
        }
        impl SILENTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LBACKR {
            bits: bool,
        }
        impl LBACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TX`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TXR {
            #[doc = "CAN Module Control"]
            CANCTL,
            #[doc = "Sample Point"]
            SAMPLE,
            #[doc = "Driven Low"]
            DOMINANT,
            #[doc = "Driven High"]
            RECESSIVE,
        }
        impl TXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TXR::CANCTL => 0,
                    TXR::SAMPLE => 0x01,
                    TXR::DOMINANT => 0x02,
                    TXR::RECESSIVE => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TXR {
                match value {
                    0 => TXR::CANCTL,
                    1 => TXR::SAMPLE,
                    2 => TXR::DOMINANT,
                    3 => TXR::RECESSIVE,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CANCTL`"]
            #[inline]
            pub fn is_canctl(&self) -> bool {
                *self == TXR::CANCTL
            }
            #[doc = "Checks if the value of the field is `SAMPLE`"]
            #[inline]
            pub fn is_sample(&self) -> bool {
                *self == TXR::SAMPLE
            }
            #[doc = "Checks if the value of the field is `DOMINANT`"]
            #[inline]
            pub fn is_dominant(&self) -> bool {
                *self == TXR::DOMINANT
            }
            #[doc = "Checks if the value of the field is `RECESSIVE`"]
            #[inline]
            pub fn is_recessive(&self) -> bool {
                *self == TXR::RECESSIVE
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXR {
            bits: bool,
        }
        impl RXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _BASICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BASICW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SILENTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SILENTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LBACKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LBACKW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TX`"]
        pub enum TXW {
            #[doc = "CAN Module Control"]
            CANCTL,
            #[doc = "Sample Point"]
            SAMPLE,
            #[doc = "Driven Low"]
            DOMINANT,
            #[doc = "Driven High"]
            RECESSIVE,
        }
        impl TXW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TXW::CANCTL => 0,
                    TXW::SAMPLE => 1,
                    TXW::DOMINANT => 2,
                    TXW::RECESSIVE => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TXW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "CAN Module Control"]
            #[inline]
            pub fn canctl(self) -> &'a mut W {
                self.variant(TXW::CANCTL)
            }
            #[doc = "Sample Point"]
            #[inline]
            pub fn sample(self) -> &'a mut W {
                self.variant(TXW::SAMPLE)
            }
            #[doc = "Driven Low"]
            #[inline]
            pub fn dominant(self) -> &'a mut W {
                self.variant(TXW::DOMINANT)
            }
            #[doc = "Driven High"]
            #[inline]
            pub fn recessive(self) -> &'a mut W {
                self.variant(TXW::RECESSIVE)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _RXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 2 - Basic Mode"]
            #[inline]
            pub fn basic(&self) -> BASICR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BASICR { bits }
            }
            #[doc = "Bit 3 - Silent Mode"]
            #[inline]
            pub fn silent(&self) -> SILENTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SILENTR { bits }
            }
            #[doc = "Bit 4 - Loopback Mode"]
            #[inline]
            pub fn lback(&self) -> LBACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LBACKR { bits }
            }
            #[doc = "Bits 5:6 - Transmit Control"]
            #[inline]
            pub fn tx(&self) -> TXR {
                TXR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Receive Observation"]
            #[inline]
            pub fn rx(&self) -> RXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXR { bits }
            }
        }
        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 = "Bit 2 - Basic Mode"]
            #[inline]
            pub fn basic(&mut self) -> _BASICW {
                _BASICW { w: self }
            }
            #[doc = "Bit 3 - Silent Mode"]
            #[inline]
            pub fn silent(&mut self) -> _SILENTW {
                _SILENTW { w: self }
            }
            #[doc = "Bit 4 - Loopback Mode"]
            #[inline]
            pub fn lback(&mut self) -> _LBACKW {
                _LBACKW { w: self }
            }
            #[doc = "Bits 5:6 - Transmit Control"]
            #[inline]
            pub fn tx(&mut self) -> _TXW {
                _TXW { w: self }
            }
            #[doc = "Bit 7 - Receive Observation"]
            #[inline]
            pub fn rx(&mut self) -> _RXW {
                _RXW { w: self }
            }
        }
    }
    #[doc = "CAN Baud Rate Prescaler Extension"]
    pub struct BRPE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Baud Rate Prescaler Extension"]
    pub mod brpe {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::BRPE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BRPER {
            bits: u8,
        }
        impl BRPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRPEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRPEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Baud Rate Prescaler Extension"]
            #[inline]
            pub fn brpe(&self) -> BRPER {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                BRPER { bits }
            }
        }
        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 0:3 - Baud Rate Prescaler Extension"]
            #[inline]
            pub fn brpe(&mut self) -> _BRPEW {
                _BRPEW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Command Request"]
    pub struct IF1CRQ {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Command Request"]
    pub mod if1crq {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1CRQ {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MNUMR {
            bits: u8,
        }
        impl MNUMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSYR {
            bits: bool,
        }
        impl BUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _MNUMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MNUMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BUSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BUSYW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Message Number"]
            #[inline]
            pub fn mnum(&self) -> MNUMR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MNUMR { bits }
            }
            #[doc = "Bit 15 - Busy Flag"]
            #[inline]
            pub fn busy(&self) -> BUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSYR { bits }
            }
        }
        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 0:5 - Message Number"]
            #[inline]
            pub fn mnum(&mut self) -> _MNUMW {
                _MNUMW { w: self }
            }
            #[doc = "Bit 15 - Busy Flag"]
            #[inline]
            pub fn busy(&mut self) -> _BUSYW {
                _BUSYW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Command Mask"]
    pub struct IF1CMSK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Command Mask"]
    pub mod if1cmsk {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1CMSK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATABR {
            bits: bool,
        }
        impl DATABR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAAR {
            bits: bool,
        }
        impl DATAAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: bool,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: bool,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRINTPNDR {
            bits: bool,
        }
        impl CLRINTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CONTROLR {
            bits: bool,
        }
        impl CONTROLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBR {
            bits: bool,
        }
        impl ARBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASKR {
            bits: bool,
        }
        impl MASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRNRDR {
            bits: bool,
        }
        impl WRNRDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATABW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATABW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAAW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NEWDATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NEWDATW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRQSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRQSTW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRINTPNDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRINTPNDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CONTROLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CONTROLW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ARBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ARBW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASKW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRNRDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRNRDW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Access Data Byte 4 to 7"]
            #[inline]
            pub fn datab(&self) -> DATABR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATABR { bits }
            }
            #[doc = "Bit 1 - Access Data Byte 0 to 3"]
            #[inline]
            pub fn dataa(&self) -> DATAAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATAAR { bits }
            }
            #[doc = "Bit 2 - Access New Data"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NEWDATR { bits }
            }
            #[doc = "Bit 2 - Access Transmission Request"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRQSTR { bits }
            }
            #[doc = "Bit 3 - Clear Interrupt Pending Bit"]
            #[inline]
            pub fn clrintpnd(&self) -> CLRINTPNDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLRINTPNDR { bits }
            }
            #[doc = "Bit 4 - Access Control Bits"]
            #[inline]
            pub fn control(&self) -> CONTROLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CONTROLR { bits }
            }
            #[doc = "Bit 5 - Access Arbitration Bits"]
            #[inline]
            pub fn arb(&self) -> ARBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBR { bits }
            }
            #[doc = "Bit 6 - Access Mask Bits"]
            #[inline]
            pub fn mask(&self) -> MASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASKR { bits }
            }
            #[doc = "Bit 7 - Write, Not Read"]
            #[inline]
            pub fn wrnrd(&self) -> WRNRDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRNRDR { bits }
            }
        }
        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 = "Bit 0 - Access Data Byte 4 to 7"]
            #[inline]
            pub fn datab(&mut self) -> _DATABW {
                _DATABW { w: self }
            }
            #[doc = "Bit 1 - Access Data Byte 0 to 3"]
            #[inline]
            pub fn dataa(&mut self) -> _DATAAW {
                _DATAAW { w: self }
            }
            #[doc = "Bit 2 - Access New Data"]
            #[inline]
            pub fn newdat(&mut self) -> _NEWDATW {
                _NEWDATW { w: self }
            }
            #[doc = "Bit 2 - Access Transmission Request"]
            #[inline]
            pub fn txrqst(&mut self) -> _TXRQSTW {
                _TXRQSTW { w: self }
            }
            #[doc = "Bit 3 - Clear Interrupt Pending Bit"]
            #[inline]
            pub fn clrintpnd(&mut self) -> _CLRINTPNDW {
                _CLRINTPNDW { w: self }
            }
            #[doc = "Bit 4 - Access Control Bits"]
            #[inline]
            pub fn control(&mut self) -> _CONTROLW {
                _CONTROLW { w: self }
            }
            #[doc = "Bit 5 - Access Arbitration Bits"]
            #[inline]
            pub fn arb(&mut self) -> _ARBW {
                _ARBW { w: self }
            }
            #[doc = "Bit 6 - Access Mask Bits"]
            #[inline]
            pub fn mask(&mut self) -> _MASKW {
                _MASKW { w: self }
            }
            #[doc = "Bit 7 - Write, Not Read"]
            #[inline]
            pub fn wrnrd(&mut self) -> _WRNRDW {
                _WRNRDW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Mask 1"]
    pub struct IF1MSK1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Mask 1"]
    pub mod if1msk1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1MSK1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDMSKR {
            bits: u16,
        }
        impl IDMSKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDMSKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDMSKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&self) -> IDMSKR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDMSKR { bits }
            }
        }
        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 0:15 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&mut self) -> _IDMSKW {
                _IDMSKW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Mask 2"]
    pub struct IF1MSK2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Mask 2"]
    pub mod if1msk2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1MSK2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDMSKR {
            bits: u16,
        }
        impl IDMSKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MDIRR {
            bits: bool,
        }
        impl MDIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MXTDR {
            bits: bool,
        }
        impl MXTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDMSKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDMSKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MDIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MDIRW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MXTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MXTDW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&self) -> IDMSKR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDMSKR { bits }
            }
            #[doc = "Bit 14 - Mask Message Direction"]
            #[inline]
            pub fn mdir(&self) -> MDIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MDIRR { bits }
            }
            #[doc = "Bit 15 - Mask Extended Identifier"]
            #[inline]
            pub fn mxtd(&self) -> MXTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MXTDR { bits }
            }
        }
        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 0:12 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&mut self) -> _IDMSKW {
                _IDMSKW { w: self }
            }
            #[doc = "Bit 14 - Mask Message Direction"]
            #[inline]
            pub fn mdir(&mut self) -> _MDIRW {
                _MDIRW { w: self }
            }
            #[doc = "Bit 15 - Mask Extended Identifier"]
            #[inline]
            pub fn mxtd(&mut self) -> _MXTDW {
                _MXTDW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Arbitration 1"]
    pub struct IF1ARB1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Arbitration 1"]
    pub mod if1arb1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1ARB1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDR {
            bits: u16,
        }
        impl IDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Message Identifier"]
            #[inline]
            pub fn id(&self) -> IDR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDR { bits }
            }
        }
        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 0:15 - Message Identifier"]
            #[inline]
            pub fn id(&mut self) -> _IDW {
                _IDW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Arbitration 2"]
    pub struct IF1ARB2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Arbitration 2"]
    pub mod if1arb2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1ARB2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDR {
            bits: u16,
        }
        impl IDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XTDR {
            bits: bool,
        }
        impl XTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGVALR {
            bits: bool,
        }
        impl MSGVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XTDW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MSGVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MSGVALW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Message Identifier"]
            #[inline]
            pub fn id(&self) -> IDR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDR { bits }
            }
            #[doc = "Bit 13 - Message Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 14 - Extended Identifier"]
            #[inline]
            pub fn xtd(&self) -> XTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XTDR { bits }
            }
            #[doc = "Bit 15 - Message Valid"]
            #[inline]
            pub fn msgval(&self) -> MSGVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSGVALR { bits }
            }
        }
        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 0:12 - Message Identifier"]
            #[inline]
            pub fn id(&mut self) -> _IDW {
                _IDW { w: self }
            }
            #[doc = "Bit 13 - Message Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 14 - Extended Identifier"]
            #[inline]
            pub fn xtd(&mut self) -> _XTDW {
                _XTDW { w: self }
            }
            #[doc = "Bit 15 - Message Valid"]
            #[inline]
            pub fn msgval(&mut self) -> _MSGVALW {
                _MSGVALW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Message Control"]
    pub struct IF1MCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Message Control"]
    pub mod if1mctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1MCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DLCR {
            bits: u8,
        }
        impl DLCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOBR {
            bits: bool,
        }
        impl EOBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: bool,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RMTENR {
            bits: bool,
        }
        impl RMTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIER {
            bits: bool,
        }
        impl RXIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIER {
            bits: bool,
        }
        impl TXIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UMASKR {
            bits: bool,
        }
        impl UMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPNDR {
            bits: bool,
        }
        impl INTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGLSTR {
            bits: bool,
        }
        impl MSGLSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: bool,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DLCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DLCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOBW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRQSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRQSTW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RMTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RMTENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIEW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIEW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UMASKW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPNDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPNDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MSGLSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MSGLSTW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NEWDATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NEWDATW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Data Length Code"]
            #[inline]
            pub fn dlc(&self) -> DLCR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DLCR { bits }
            }
            #[doc = "Bit 7 - End of Buffer"]
            #[inline]
            pub fn eob(&self) -> EOBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOBR { bits }
            }
            #[doc = "Bit 8 - Transmit Request"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRQSTR { bits }
            }
            #[doc = "Bit 9 - Remote Enable"]
            #[inline]
            pub fn rmten(&self) -> RMTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RMTENR { bits }
            }
            #[doc = "Bit 10 - Receive Interrupt Enable"]
            #[inline]
            pub fn rxie(&self) -> RXIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIER { bits }
            }
            #[doc = "Bit 11 - Transmit Interrupt Enable"]
            #[inline]
            pub fn txie(&self) -> TXIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIER { bits }
            }
            #[doc = "Bit 12 - Use Acceptance Mask"]
            #[inline]
            pub fn umask(&self) -> UMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UMASKR { bits }
            }
            #[doc = "Bit 13 - Interrupt Pending"]
            #[inline]
            pub fn intpnd(&self) -> INTPNDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPNDR { bits }
            }
            #[doc = "Bit 14 - Message Lost"]
            #[inline]
            pub fn msglst(&self) -> MSGLSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSGLSTR { bits }
            }
            #[doc = "Bit 15 - New Data"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NEWDATR { bits }
            }
        }
        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 0:3 - Data Length Code"]
            #[inline]
            pub fn dlc(&mut self) -> _DLCW {
                _DLCW { w: self }
            }
            #[doc = "Bit 7 - End of Buffer"]
            #[inline]
            pub fn eob(&mut self) -> _EOBW {
                _EOBW { w: self }
            }
            #[doc = "Bit 8 - Transmit Request"]
            #[inline]
            pub fn txrqst(&mut self) -> _TXRQSTW {
                _TXRQSTW { w: self }
            }
            #[doc = "Bit 9 - Remote Enable"]
            #[inline]
            pub fn rmten(&mut self) -> _RMTENW {
                _RMTENW { w: self }
            }
            #[doc = "Bit 10 - Receive Interrupt Enable"]
            #[inline]
            pub fn rxie(&mut self) -> _RXIEW {
                _RXIEW { w: self }
            }
            #[doc = "Bit 11 - Transmit Interrupt Enable"]
            #[inline]
            pub fn txie(&mut self) -> _TXIEW {
                _TXIEW { w: self }
            }
            #[doc = "Bit 12 - Use Acceptance Mask"]
            #[inline]
            pub fn umask(&mut self) -> _UMASKW {
                _UMASKW { w: self }
            }
            #[doc = "Bit 13 - Interrupt Pending"]
            #[inline]
            pub fn intpnd(&mut self) -> _INTPNDW {
                _INTPNDW { w: self }
            }
            #[doc = "Bit 14 - Message Lost"]
            #[inline]
            pub fn msglst(&mut self) -> _MSGLSTW {
                _MSGLSTW { w: self }
            }
            #[doc = "Bit 15 - New Data"]
            #[inline]
            pub fn newdat(&mut self) -> _NEWDATW {
                _NEWDATW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Data A1"]
    pub struct IF1DA1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Data A1"]
    pub mod if1da1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1DA1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Data A2"]
    pub struct IF1DA2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Data A2"]
    pub mod if1da2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1DA2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Data B1"]
    pub struct IF1DB1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Data B1"]
    pub mod if1db1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1DB1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF1 Data B2"]
    pub struct IF1DB2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF1 Data B2"]
    pub mod if1db2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF1DB2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Command Request"]
    pub struct IF2CRQ {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Command Request"]
    pub mod if2crq {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2CRQ {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MNUMR {
            bits: u8,
        }
        impl MNUMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct BUSYR {
            bits: bool,
        }
        impl BUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _MNUMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MNUMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BUSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BUSYW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Message Number"]
            #[inline]
            pub fn mnum(&self) -> MNUMR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MNUMR { bits }
            }
            #[doc = "Bit 15 - Busy Flag"]
            #[inline]
            pub fn busy(&self) -> BUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BUSYR { bits }
            }
        }
        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 0:5 - Message Number"]
            #[inline]
            pub fn mnum(&mut self) -> _MNUMW {
                _MNUMW { w: self }
            }
            #[doc = "Bit 15 - Busy Flag"]
            #[inline]
            pub fn busy(&mut self) -> _BUSYW {
                _BUSYW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Command Mask"]
    pub struct IF2CMSK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Command Mask"]
    pub mod if2cmsk {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2CMSK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATABR {
            bits: bool,
        }
        impl DATABR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAAR {
            bits: bool,
        }
        impl DATAAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: bool,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: bool,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRINTPNDR {
            bits: bool,
        }
        impl CLRINTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CONTROLR {
            bits: bool,
        }
        impl CONTROLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARBR {
            bits: bool,
        }
        impl ARBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASKR {
            bits: bool,
        }
        impl MASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRNRDR {
            bits: bool,
        }
        impl WRNRDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATABW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATABW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAAW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NEWDATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NEWDATW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRQSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRQSTW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRINTPNDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRINTPNDW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CONTROLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CONTROLW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ARBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ARBW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASKW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRNRDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRNRDW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Access Data Byte 4 to 7"]
            #[inline]
            pub fn datab(&self) -> DATABR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATABR { bits }
            }
            #[doc = "Bit 1 - Access Data Byte 0 to 3"]
            #[inline]
            pub fn dataa(&self) -> DATAAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DATAAR { bits }
            }
            #[doc = "Bit 2 - Access New Data"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NEWDATR { bits }
            }
            #[doc = "Bit 2 - Access Transmission Request"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRQSTR { bits }
            }
            #[doc = "Bit 3 - Clear Interrupt Pending Bit"]
            #[inline]
            pub fn clrintpnd(&self) -> CLRINTPNDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLRINTPNDR { bits }
            }
            #[doc = "Bit 4 - Access Control Bits"]
            #[inline]
            pub fn control(&self) -> CONTROLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CONTROLR { bits }
            }
            #[doc = "Bit 5 - Access Arbitration Bits"]
            #[inline]
            pub fn arb(&self) -> ARBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARBR { bits }
            }
            #[doc = "Bit 6 - Access Mask Bits"]
            #[inline]
            pub fn mask(&self) -> MASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASKR { bits }
            }
            #[doc = "Bit 7 - Write, Not Read"]
            #[inline]
            pub fn wrnrd(&self) -> WRNRDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRNRDR { bits }
            }
        }
        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 = "Bit 0 - Access Data Byte 4 to 7"]
            #[inline]
            pub fn datab(&mut self) -> _DATABW {
                _DATABW { w: self }
            }
            #[doc = "Bit 1 - Access Data Byte 0 to 3"]
            #[inline]
            pub fn dataa(&mut self) -> _DATAAW {
                _DATAAW { w: self }
            }
            #[doc = "Bit 2 - Access New Data"]
            #[inline]
            pub fn newdat(&mut self) -> _NEWDATW {
                _NEWDATW { w: self }
            }
            #[doc = "Bit 2 - Access Transmission Request"]
            #[inline]
            pub fn txrqst(&mut self) -> _TXRQSTW {
                _TXRQSTW { w: self }
            }
            #[doc = "Bit 3 - Clear Interrupt Pending Bit"]
            #[inline]
            pub fn clrintpnd(&mut self) -> _CLRINTPNDW {
                _CLRINTPNDW { w: self }
            }
            #[doc = "Bit 4 - Access Control Bits"]
            #[inline]
            pub fn control(&mut self) -> _CONTROLW {
                _CONTROLW { w: self }
            }
            #[doc = "Bit 5 - Access Arbitration Bits"]
            #[inline]
            pub fn arb(&mut self) -> _ARBW {
                _ARBW { w: self }
            }
            #[doc = "Bit 6 - Access Mask Bits"]
            #[inline]
            pub fn mask(&mut self) -> _MASKW {
                _MASKW { w: self }
            }
            #[doc = "Bit 7 - Write, Not Read"]
            #[inline]
            pub fn wrnrd(&mut self) -> _WRNRDW {
                _WRNRDW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Mask 1"]
    pub struct IF2MSK1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Mask 1"]
    pub mod if2msk1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2MSK1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDMSKR {
            bits: u16,
        }
        impl IDMSKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDMSKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDMSKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&self) -> IDMSKR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDMSKR { bits }
            }
        }
        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 0:15 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&mut self) -> _IDMSKW {
                _IDMSKW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Mask 2"]
    pub struct IF2MSK2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Mask 2"]
    pub mod if2msk2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2MSK2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDMSKR {
            bits: u16,
        }
        impl IDMSKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MDIRR {
            bits: bool,
        }
        impl MDIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MXTDR {
            bits: bool,
        }
        impl MXTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDMSKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDMSKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MDIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MDIRW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MXTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MXTDW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&self) -> IDMSKR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDMSKR { bits }
            }
            #[doc = "Bit 14 - Mask Message Direction"]
            #[inline]
            pub fn mdir(&self) -> MDIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MDIRR { bits }
            }
            #[doc = "Bit 15 - Mask Extended Identifier"]
            #[inline]
            pub fn mxtd(&self) -> MXTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MXTDR { bits }
            }
        }
        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 0:12 - Identifier Mask"]
            #[inline]
            pub fn idmsk(&mut self) -> _IDMSKW {
                _IDMSKW { w: self }
            }
            #[doc = "Bit 14 - Mask Message Direction"]
            #[inline]
            pub fn mdir(&mut self) -> _MDIRW {
                _MDIRW { w: self }
            }
            #[doc = "Bit 15 - Mask Extended Identifier"]
            #[inline]
            pub fn mxtd(&mut self) -> _MXTDW {
                _MXTDW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Arbitration 1"]
    pub struct IF2ARB1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Arbitration 1"]
    pub mod if2arb1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2ARB1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDR {
            bits: u16,
        }
        impl IDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Message Identifier"]
            #[inline]
            pub fn id(&self) -> IDR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDR { bits }
            }
        }
        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 0:15 - Message Identifier"]
            #[inline]
            pub fn id(&mut self) -> _IDW {
                _IDW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Arbitration 2"]
    pub struct IF2ARB2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Arbitration 2"]
    pub mod if2arb2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2ARB2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct IDR {
            bits: u16,
        }
        impl IDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XTDR {
            bits: bool,
        }
        impl XTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGVALR {
            bits: bool,
        }
        impl MSGVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _IDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XTDW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MSGVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MSGVALW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Message Identifier"]
            #[inline]
            pub fn id(&self) -> IDR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                IDR { bits }
            }
            #[doc = "Bit 13 - Message Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 14 - Extended Identifier"]
            #[inline]
            pub fn xtd(&self) -> XTDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XTDR { bits }
            }
            #[doc = "Bit 15 - Message Valid"]
            #[inline]
            pub fn msgval(&self) -> MSGVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSGVALR { bits }
            }
        }
        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 0:12 - Message Identifier"]
            #[inline]
            pub fn id(&mut self) -> _IDW {
                _IDW { w: self }
            }
            #[doc = "Bit 13 - Message Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 14 - Extended Identifier"]
            #[inline]
            pub fn xtd(&mut self) -> _XTDW {
                _XTDW { w: self }
            }
            #[doc = "Bit 15 - Message Valid"]
            #[inline]
            pub fn msgval(&mut self) -> _MSGVALW {
                _MSGVALW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Message Control"]
    pub struct IF2MCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Message Control"]
    pub mod if2mctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2MCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DLCR {
            bits: u8,
        }
        impl DLCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EOBR {
            bits: bool,
        }
        impl EOBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: bool,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RMTENR {
            bits: bool,
        }
        impl RMTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXIER {
            bits: bool,
        }
        impl RXIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXIER {
            bits: bool,
        }
        impl TXIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UMASKR {
            bits: bool,
        }
        impl UMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPNDR {
            bits: bool,
        }
        impl INTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGLSTR {
            bits: bool,
        }
        impl MSGLSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: bool,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DLCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DLCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EOBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EOBW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRQSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRQSTW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RMTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RMTENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXIEW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXIEW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UMASKW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTPNDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTPNDW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MSGLSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MSGLSTW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NEWDATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NEWDATW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Data Length Code"]
            #[inline]
            pub fn dlc(&self) -> DLCR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DLCR { bits }
            }
            #[doc = "Bit 7 - End of Buffer"]
            #[inline]
            pub fn eob(&self) -> EOBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EOBR { bits }
            }
            #[doc = "Bit 8 - Transmit Request"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXRQSTR { bits }
            }
            #[doc = "Bit 9 - Remote Enable"]
            #[inline]
            pub fn rmten(&self) -> RMTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RMTENR { bits }
            }
            #[doc = "Bit 10 - Receive Interrupt Enable"]
            #[inline]
            pub fn rxie(&self) -> RXIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXIER { bits }
            }
            #[doc = "Bit 11 - Transmit Interrupt Enable"]
            #[inline]
            pub fn txie(&self) -> TXIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXIER { bits }
            }
            #[doc = "Bit 12 - Use Acceptance Mask"]
            #[inline]
            pub fn umask(&self) -> UMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UMASKR { bits }
            }
            #[doc = "Bit 13 - Interrupt Pending"]
            #[inline]
            pub fn intpnd(&self) -> INTPNDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTPNDR { bits }
            }
            #[doc = "Bit 14 - Message Lost"]
            #[inline]
            pub fn msglst(&self) -> MSGLSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MSGLSTR { bits }
            }
            #[doc = "Bit 15 - New Data"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NEWDATR { bits }
            }
        }
        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 0:3 - Data Length Code"]
            #[inline]
            pub fn dlc(&mut self) -> _DLCW {
                _DLCW { w: self }
            }
            #[doc = "Bit 7 - End of Buffer"]
            #[inline]
            pub fn eob(&mut self) -> _EOBW {
                _EOBW { w: self }
            }
            #[doc = "Bit 8 - Transmit Request"]
            #[inline]
            pub fn txrqst(&mut self) -> _TXRQSTW {
                _TXRQSTW { w: self }
            }
            #[doc = "Bit 9 - Remote Enable"]
            #[inline]
            pub fn rmten(&mut self) -> _RMTENW {
                _RMTENW { w: self }
            }
            #[doc = "Bit 10 - Receive Interrupt Enable"]
            #[inline]
            pub fn rxie(&mut self) -> _RXIEW {
                _RXIEW { w: self }
            }
            #[doc = "Bit 11 - Transmit Interrupt Enable"]
            #[inline]
            pub fn txie(&mut self) -> _TXIEW {
                _TXIEW { w: self }
            }
            #[doc = "Bit 12 - Use Acceptance Mask"]
            #[inline]
            pub fn umask(&mut self) -> _UMASKW {
                _UMASKW { w: self }
            }
            #[doc = "Bit 13 - Interrupt Pending"]
            #[inline]
            pub fn intpnd(&mut self) -> _INTPNDW {
                _INTPNDW { w: self }
            }
            #[doc = "Bit 14 - Message Lost"]
            #[inline]
            pub fn msglst(&mut self) -> _MSGLSTW {
                _MSGLSTW { w: self }
            }
            #[doc = "Bit 15 - New Data"]
            #[inline]
            pub fn newdat(&mut self) -> _NEWDATW {
                _NEWDATW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Data A1"]
    pub struct IF2DA1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Data A1"]
    pub mod if2da1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2DA1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Data A2"]
    pub struct IF2DA2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Data A2"]
    pub mod if2da2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2DA2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Data B1"]
    pub struct IF2DB1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Data B1"]
    pub mod if2db1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2DB1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN IF2 Data B2"]
    pub struct IF2DB2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN IF2 Data B2"]
    pub mod if2db2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IF2DB2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "CAN Transmission Request 1"]
    pub struct TXRQ1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Transmission Request 1"]
    pub mod txrq1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXRQ1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: u16,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Transmission Request Bits"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                TXRQSTR { bits }
            }
        }
    }
    #[doc = "CAN Transmission Request 2"]
    pub struct TXRQ2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Transmission Request 2"]
    pub mod txrq2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXRQ2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRQSTR {
            bits: u16,
        }
        impl TXRQSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Transmission Request Bits"]
            #[inline]
            pub fn txrqst(&self) -> TXRQSTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                TXRQSTR { bits }
            }
        }
    }
    #[doc = "CAN New Data 1"]
    pub struct NWDA1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN New Data 1"]
    pub mod nwda1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::NWDA1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: u16,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - New Data Bits"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                NEWDATR { bits }
            }
        }
    }
    #[doc = "CAN New Data 2"]
    pub struct NWDA2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN New Data 2"]
    pub mod nwda2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::NWDA2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWDATR {
            bits: u16,
        }
        impl NEWDATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - New Data Bits"]
            #[inline]
            pub fn newdat(&self) -> NEWDATR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                NEWDATR { bits }
            }
        }
    }
    #[doc = "CAN Message 1 Interrupt Pending"]
    pub struct MSG1INT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Message 1 Interrupt Pending"]
    pub mod msg1int {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MSG1INT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPNDR {
            bits: u16,
        }
        impl INTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Interrupt Pending Bits"]
            #[inline]
            pub fn intpnd(&self) -> INTPNDR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                INTPNDR { bits }
            }
        }
    }
    #[doc = "CAN Message 2 Interrupt Pending"]
    pub struct MSG2INT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Message 2 Interrupt Pending"]
    pub mod msg2int {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MSG2INT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTPNDR {
            bits: u16,
        }
        impl INTPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Interrupt Pending Bits"]
            #[inline]
            pub fn intpnd(&self) -> INTPNDR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                INTPNDR { bits }
            }
        }
    }
    #[doc = "CAN Message 1 Valid"]
    pub struct MSG1VAL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Message 1 Valid"]
    pub mod msg1val {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MSG1VAL {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGVALR {
            bits: u16,
        }
        impl MSGVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Message Valid Bits"]
            #[inline]
            pub fn msgval(&self) -> MSGVALR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MSGVALR { bits }
            }
        }
    }
    #[doc = "CAN Message 2 Valid"]
    pub struct MSG2VAL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CAN Message 2 Valid"]
    pub mod msg2val {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MSG2VAL {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct MSGVALR {
            bits: u16,
        }
        impl MSGVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Message Valid Bits"]
            #[inline]
            pub fn msgval(&self) -> MSGVALR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MSGVALR { bits }
            }
        }
    }
}
#[doc = "CAN1"]
pub struct CAN1 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CAN1 {}
impl CAN1 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const can0::RegisterBlock {
        0x4004_1000 as *const _
    }
}
impl Deref for CAN1 {
    type Target = can0::RegisterBlock;
    fn deref(&self) -> &can0::RegisterBlock {
        unsafe { &*CAN1::ptr() }
    }
}
#[doc = "Univeral Serial Bus register offsets"]
pub struct USB0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for USB0 {}
impl USB0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const usb0::RegisterBlock {
        0x4005_0000 as *const _
    }
}
impl Deref for USB0 {
    type Target = usb0::RegisterBlock;
    fn deref(&self) -> &usb0::RegisterBlock {
        unsafe { &*USB0::ptr() }
    }
}
#[doc = "Univeral Serial Bus register offsets"]
pub mod usb0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - USB Device Functional Address"]
        pub faddr: FADDR,
        #[doc = "0x01 - USB Power"]
        pub power: POWER,
        #[doc = "0x02 - USB Transmit Interrupt Status"]
        pub txis: TXIS,
        #[doc = "0x04 - USB Receive Interrupt Status"]
        pub rxis: RXIS,
        #[doc = "0x06 - USB Transmit Interrupt Enable"]
        pub txie: TXIE,
        #[doc = "0x08 - USB Receive Interrupt Enable"]
        pub rxie: RXIE,
        #[doc = "0x0a - USB General Interrupt Status"]
        pub is: IS,
        #[doc = "0x0b - USB Interrupt Enable"]
        pub ie: IE,
        #[doc = "0x0c - USB Frame Value"]
        pub frame: FRAME,
        #[doc = "0x0e - USB Endpoint Index"]
        pub epidx: EPIDX,
        #[doc = "0x0f - USB Test Mode"]
        pub test: TEST,
        _reserved0: [u8; 16usize],
        #[doc = "0x20 - USB FIFO Endpoint 0"]
        pub fifo0: FIFO0,
        #[doc = "0x24 - USB FIFO Endpoint 1"]
        pub fifo1: FIFO1,
        #[doc = "0x28 - USB FIFO Endpoint 2"]
        pub fifo2: FIFO2,
        #[doc = "0x2c - USB FIFO Endpoint 3"]
        pub fifo3: FIFO3,
        #[doc = "0x30 - USB FIFO Endpoint 4"]
        pub fifo4: FIFO4,
        #[doc = "0x34 - USB FIFO Endpoint 5"]
        pub fifo5: FIFO5,
        #[doc = "0x38 - USB FIFO Endpoint 6"]
        pub fifo6: FIFO6,
        #[doc = "0x3c - USB FIFO Endpoint 7"]
        pub fifo7: FIFO7,
        _reserved1: [u8; 32usize],
        #[doc = "0x60 - USB Device Control"]
        pub devctl: DEVCTL,
        #[doc = "0x61 - USB Common Configuration"]
        pub cconf: CCONF,
        #[doc = "0x62 - USB Transmit Dynamic FIFO Sizing"]
        pub txfifosz: TXFIFOSZ,
        #[doc = "0x63 - USB Receive Dynamic FIFO Sizing"]
        pub rxfifosz: RXFIFOSZ,
        #[doc = "0x64 - USB Transmit FIFO Start Address"]
        pub txfifoadd: TXFIFOADD,
        #[doc = "0x66 - USB Receive FIFO Start Address"]
        pub rxfifoadd: RXFIFOADD,
        _reserved2: [u8; 8usize],
        #[doc = "0x70 - USB ULPI VBUS Control"]
        pub ulpivbusctl: ULPIVBUSCTL,
        _reserved3: [u8; 3usize],
        #[doc = "0x74 - USB ULPI Register Data"]
        pub ulpiregdata: ULPIREGDATA,
        #[doc = "0x75 - USB ULPI Register Address"]
        pub ulpiregaddr: ULPIREGADDR,
        #[doc = "0x76 - USB ULPI Register Control"]
        pub ulpiregctl: ULPIREGCTL,
        _reserved4: [u8; 1usize],
        #[doc = "0x78 - USB Endpoint Information"]
        pub epinfo: EPINFO,
        #[doc = "0x79 - USB RAM Information"]
        pub raminfo: RAMINFO,
        #[doc = "0x7a - USB Connect Timing"]
        pub contim: CONTIM,
        #[doc = "0x7b - USB OTG VBUS Pulse Timing"]
        pub vplen: VPLEN,
        #[doc = "0x7c - USB High-Speed Last Transaction to End of Frame Timing"]
        pub hseof: HSEOF,
        #[doc = "0x7d - USB Full-Speed Last Transaction to End of Frame Timing"]
        pub fseof: FSEOF,
        #[doc = "0x7e - USB Low-Speed Last Transaction to End of Frame Timing"]
        pub lseof: LSEOF,
        _reserved5: [u8; 1usize],
        #[doc = "0x80 - USB Transmit Functional Address Endpoint 0"]
        pub txfuncaddr0: TXFUNCADDR0,
        _reserved6: [u8; 1usize],
        #[doc = "0x82 - USB Transmit Hub Address Endpoint 0"]
        pub txhubaddr0: TXHUBADDR0,
        #[doc = "0x83 - USB Transmit Hub Port Endpoint 0"]
        pub txhubport0: TXHUBPORT0,
        _reserved7: [u8; 4usize],
        #[doc = "0x88 - USB Transmit Functional Address Endpoint 1"]
        pub txfuncaddr1: TXFUNCADDR1,
        _reserved8: [u8; 1usize],
        #[doc = "0x8a - USB Transmit Hub Address Endpoint 1"]
        pub txhubaddr1: TXHUBADDR1,
        #[doc = "0x8b - USB Transmit Hub Port Endpoint 1"]
        pub txhubport1: TXHUBPORT1,
        #[doc = "0x8c - USB Receive Functional Address Endpoint 1"]
        pub rxfuncaddr1: RXFUNCADDR1,
        _reserved9: [u8; 1usize],
        #[doc = "0x8e - USB Receive Hub Address Endpoint 1"]
        pub rxhubaddr1: RXHUBADDR1,
        #[doc = "0x8f - USB Receive Hub Port Endpoint 1"]
        pub rxhubport1: RXHUBPORT1,
        #[doc = "0x90 - USB Transmit Functional Address Endpoint 2"]
        pub txfuncaddr2: TXFUNCADDR2,
        _reserved10: [u8; 1usize],
        #[doc = "0x92 - USB Transmit Hub Address Endpoint 2"]
        pub txhubaddr2: TXHUBADDR2,
        #[doc = "0x93 - USB Transmit Hub Port Endpoint 2"]
        pub txhubport2: TXHUBPORT2,
        #[doc = "0x94 - USB Receive Functional Address Endpoint 2"]
        pub rxfuncaddr2: RXFUNCADDR2,
        _reserved11: [u8; 1usize],
        #[doc = "0x96 - USB Receive Hub Address Endpoint 2"]
        pub rxhubaddr2: RXHUBADDR2,
        #[doc = "0x97 - USB Receive Hub Port Endpoint 2"]
        pub rxhubport2: RXHUBPORT2,
        #[doc = "0x98 - USB Transmit Functional Address Endpoint 3"]
        pub txfuncaddr3: TXFUNCADDR3,
        _reserved12: [u8; 1usize],
        #[doc = "0x9a - USB Transmit Hub Address Endpoint 3"]
        pub txhubaddr3: TXHUBADDR3,
        #[doc = "0x9b - USB Transmit Hub Port Endpoint 3"]
        pub txhubport3: TXHUBPORT3,
        #[doc = "0x9c - USB Receive Functional Address Endpoint 3"]
        pub rxfuncaddr3: RXFUNCADDR3,
        _reserved13: [u8; 1usize],
        #[doc = "0x9e - USB Receive Hub Address Endpoint 3"]
        pub rxhubaddr3: RXHUBADDR3,
        #[doc = "0x9f - USB Receive Hub Port Endpoint 3"]
        pub rxhubport3: RXHUBPORT3,
        #[doc = "0xa0 - USB Transmit Functional Address Endpoint 4"]
        pub txfuncaddr4: TXFUNCADDR4,
        _reserved14: [u8; 1usize],
        #[doc = "0xa2 - USB Transmit Hub Address Endpoint 4"]
        pub txhubaddr4: TXHUBADDR4,
        #[doc = "0xa3 - USB Transmit Hub Port Endpoint 4"]
        pub txhubport4: TXHUBPORT4,
        #[doc = "0xa4 - USB Receive Functional Address Endpoint 4"]
        pub rxfuncaddr4: RXFUNCADDR4,
        _reserved15: [u8; 1usize],
        #[doc = "0xa6 - USB Receive Hub Address Endpoint 4"]
        pub rxhubaddr4: RXHUBADDR4,
        #[doc = "0xa7 - USB Receive Hub Port Endpoint 4"]
        pub rxhubport4: RXHUBPORT4,
        #[doc = "0xa8 - USB Transmit Functional Address Endpoint 5"]
        pub txfuncaddr5: TXFUNCADDR5,
        _reserved16: [u8; 1usize],
        #[doc = "0xaa - USB Transmit Hub Address Endpoint 5"]
        pub txhubaddr5: TXHUBADDR5,
        #[doc = "0xab - USB Transmit Hub Port Endpoint 5"]
        pub txhubport5: TXHUBPORT5,
        #[doc = "0xac - USB Receive Functional Address Endpoint 5"]
        pub rxfuncaddr5: RXFUNCADDR5,
        _reserved17: [u8; 1usize],
        #[doc = "0xae - USB Receive Hub Address Endpoint 5"]
        pub rxhubaddr5: RXHUBADDR5,
        #[doc = "0xaf - USB Receive Hub Port Endpoint 5"]
        pub rxhubport5: RXHUBPORT5,
        #[doc = "0xb0 - USB Transmit Functional Address Endpoint 6"]
        pub txfuncaddr6: TXFUNCADDR6,
        _reserved18: [u8; 1usize],
        #[doc = "0xb2 - USB Transmit Hub Address Endpoint 6"]
        pub txhubaddr6: TXHUBADDR6,
        #[doc = "0xb3 - USB Transmit Hub Port Endpoint 6"]
        pub txhubport6: TXHUBPORT6,
        #[doc = "0xb4 - USB Receive Functional Address Endpoint 6"]
        pub rxfuncaddr6: RXFUNCADDR6,
        _reserved19: [u8; 1usize],
        #[doc = "0xb6 - USB Receive Hub Address Endpoint 6"]
        pub rxhubaddr6: RXHUBADDR6,
        #[doc = "0xb7 - USB Receive Hub Port Endpoint 6"]
        pub rxhubport6: RXHUBPORT6,
        #[doc = "0xb8 - USB Transmit Functional Address Endpoint 7"]
        pub txfuncaddr7: TXFUNCADDR7,
        _reserved20: [u8; 1usize],
        #[doc = "0xba - USB Transmit Hub Address Endpoint 7"]
        pub txhubaddr7: TXHUBADDR7,
        #[doc = "0xbb - USB Transmit Hub Port Endpoint 7"]
        pub txhubport7: TXHUBPORT7,
        #[doc = "0xbc - USB Receive Functional Address Endpoint 7"]
        pub rxfuncaddr7: RXFUNCADDR7,
        _reserved21: [u8; 1usize],
        #[doc = "0xbe - USB Receive Hub Address Endpoint 7"]
        pub rxhubaddr7: RXHUBADDR7,
        #[doc = "0xbf - USB Receive Hub Port Endpoint 7"]
        pub rxhubport7: RXHUBPORT7,
        _reserved22: [u8; 66usize],
        #[doc = "0x102 - USB Control and Status Endpoint 0 Low"]
        pub csrl0: CSRL0,
        #[doc = "0x103 - USB Control and Status Endpoint 0 High"]
        pub csrh0: CSRH0,
        _reserved23: [u8; 4usize],
        #[doc = "0x108 - USB Receive Byte Count Endpoint 0"]
        pub count0: COUNT0,
        _reserved24: [u8; 1usize],
        #[doc = "0x10a - USB Type Endpoint 0"]
        pub type0: TYPE0,
        #[doc = "0x10b - USB NAK Limit"]
        pub naklmt: NAKLMT,
        _reserved25: [u8; 4usize],
        #[doc = "0x110 - USB Maximum Transmit Data Endpoint 1"]
        pub txmaxp1: TXMAXP1,
        #[doc = "0x112 - USB Transmit Control and Status Endpoint 1 Low"]
        pub txcsrl1: TXCSRL1,
        #[doc = "0x113 - USB Transmit Control and Status Endpoint 1 High"]
        pub txcsrh1: TXCSRH1,
        #[doc = "0x114 - USB Maximum Receive Data Endpoint 1"]
        pub rxmaxp1: RXMAXP1,
        #[doc = "0x116 - USB Receive Control and Status Endpoint 1 Low"]
        pub rxcsrl1: RXCSRL1,
        #[doc = "0x117 - USB Receive Control and Status Endpoint 1 High"]
        pub rxcsrh1: RXCSRH1,
        #[doc = "0x118 - USB Receive Byte Count Endpoint 1"]
        pub rxcount1: RXCOUNT1,
        #[doc = "0x11a - USB Host Transmit Configure Type Endpoint 1"]
        pub txtype1: TXTYPE1,
        #[doc = "0x11b - USB Host Transmit Interval Endpoint 1"]
        pub txinterval1: TXINTERVAL1,
        #[doc = "0x11c - USB Host Configure Receive Type Endpoint 1"]
        pub rxtype1: RXTYPE1,
        #[doc = "0x11d - USB Host Receive Polling Interval Endpoint 1"]
        pub rxinterval1: RXINTERVAL1,
        _reserved26: [u8; 2usize],
        #[doc = "0x120 - USB Maximum Transmit Data Endpoint 2"]
        pub txmaxp2: TXMAXP2,
        #[doc = "0x122 - USB Transmit Control and Status Endpoint 2 Low"]
        pub txcsrl2: TXCSRL2,
        #[doc = "0x123 - USB Transmit Control and Status Endpoint 2 High"]
        pub txcsrh2: TXCSRH2,
        #[doc = "0x124 - USB Maximum Receive Data Endpoint 2"]
        pub rxmaxp2: RXMAXP2,
        #[doc = "0x126 - USB Receive Control and Status Endpoint 2 Low"]
        pub rxcsrl2: RXCSRL2,
        #[doc = "0x127 - USB Receive Control and Status Endpoint 2 High"]
        pub rxcsrh2: RXCSRH2,
        #[doc = "0x128 - USB Receive Byte Count Endpoint 2"]
        pub rxcount2: RXCOUNT2,
        #[doc = "0x12a - USB Host Transmit Configure Type Endpoint 2"]
        pub txtype2: TXTYPE2,
        #[doc = "0x12b - USB Host Transmit Interval Endpoint 2"]
        pub txinterval2: TXINTERVAL2,
        #[doc = "0x12c - USB Host Configure Receive Type Endpoint 2"]
        pub rxtype2: RXTYPE2,
        #[doc = "0x12d - USB Host Receive Polling Interval Endpoint 2"]
        pub rxinterval2: RXINTERVAL2,
        _reserved27: [u8; 2usize],
        #[doc = "0x130 - USB Maximum Transmit Data Endpoint 3"]
        pub txmaxp3: TXMAXP3,
        #[doc = "0x132 - USB Transmit Control and Status Endpoint 3 Low"]
        pub txcsrl3: TXCSRL3,
        #[doc = "0x133 - USB Transmit Control and Status Endpoint 3 High"]
        pub txcsrh3: TXCSRH3,
        #[doc = "0x134 - USB Maximum Receive Data Endpoint 3"]
        pub rxmaxp3: RXMAXP3,
        #[doc = "0x136 - USB Receive Control and Status Endpoint 3 Low"]
        pub rxcsrl3: RXCSRL3,
        #[doc = "0x137 - USB Receive Control and Status Endpoint 3 High"]
        pub rxcsrh3: RXCSRH3,
        #[doc = "0x138 - USB Receive Byte Count Endpoint 3"]
        pub rxcount3: RXCOUNT3,
        #[doc = "0x13a - USB Host Transmit Configure Type Endpoint 3"]
        pub txtype3: TXTYPE3,
        #[doc = "0x13b - USB Host Transmit Interval Endpoint 3"]
        pub txinterval3: TXINTERVAL3,
        #[doc = "0x13c - USB Host Configure Receive Type Endpoint 3"]
        pub rxtype3: RXTYPE3,
        #[doc = "0x13d - USB Host Receive Polling Interval Endpoint 3"]
        pub rxinterval3: RXINTERVAL3,
        _reserved28: [u8; 2usize],
        #[doc = "0x140 - USB Maximum Transmit Data Endpoint 4"]
        pub txmaxp4: TXMAXP4,
        #[doc = "0x142 - USB Transmit Control and Status Endpoint 4 Low"]
        pub txcsrl4: TXCSRL4,
        #[doc = "0x143 - USB Transmit Control and Status Endpoint 4 High"]
        pub txcsrh4: TXCSRH4,
        #[doc = "0x144 - USB Maximum Receive Data Endpoint 4"]
        pub rxmaxp4: RXMAXP4,
        #[doc = "0x146 - USB Receive Control and Status Endpoint 4 Low"]
        pub rxcsrl4: RXCSRL4,
        #[doc = "0x147 - USB Receive Control and Status Endpoint 4 High"]
        pub rxcsrh4: RXCSRH4,
        #[doc = "0x148 - USB Receive Byte Count Endpoint 4"]
        pub rxcount4: RXCOUNT4,
        #[doc = "0x14a - USB Host Transmit Configure Type Endpoint 4"]
        pub txtype4: TXTYPE4,
        #[doc = "0x14b - USB Host Transmit Interval Endpoint 4"]
        pub txinterval4: TXINTERVAL4,
        #[doc = "0x14c - USB Host Configure Receive Type Endpoint 4"]
        pub rxtype4: RXTYPE4,
        #[doc = "0x14d - USB Host Receive Polling Interval Endpoint 4"]
        pub rxinterval4: RXINTERVAL4,
        _reserved29: [u8; 2usize],
        #[doc = "0x150 - USB Maximum Transmit Data Endpoint 5"]
        pub txmaxp5: TXMAXP5,
        #[doc = "0x152 - USB Transmit Control and Status Endpoint 5 Low"]
        pub txcsrl5: TXCSRL5,
        #[doc = "0x153 - USB Transmit Control and Status Endpoint 5 High"]
        pub txcsrh5: TXCSRH5,
        #[doc = "0x154 - USB Maximum Receive Data Endpoint 5"]
        pub rxmaxp5: RXMAXP5,
        #[doc = "0x156 - USB Receive Control and Status Endpoint 5 Low"]
        pub rxcsrl5: RXCSRL5,
        #[doc = "0x157 - USB Receive Control and Status Endpoint 5 High"]
        pub rxcsrh5: RXCSRH5,
        #[doc = "0x158 - USB Receive Byte Count Endpoint 5"]
        pub rxcount5: RXCOUNT5,
        #[doc = "0x15a - USB Host Transmit Configure Type Endpoint 5"]
        pub txtype5: TXTYPE5,
        #[doc = "0x15b - USB Host Transmit Interval Endpoint 5"]
        pub txinterval5: TXINTERVAL5,
        #[doc = "0x15c - USB Host Configure Receive Type Endpoint 5"]
        pub rxtype5: RXTYPE5,
        #[doc = "0x15d - USB Host Receive Polling Interval Endpoint 5"]
        pub rxinterval5: RXINTERVAL5,
        _reserved30: [u8; 2usize],
        #[doc = "0x160 - USB Maximum Transmit Data Endpoint 6"]
        pub txmaxp6: TXMAXP6,
        #[doc = "0x162 - USB Transmit Control and Status Endpoint 6 Low"]
        pub txcsrl6: TXCSRL6,
        #[doc = "0x163 - USB Transmit Control and Status Endpoint 6 High"]
        pub txcsrh6: TXCSRH6,
        #[doc = "0x164 - USB Maximum Receive Data Endpoint 6"]
        pub rxmaxp6: RXMAXP6,
        #[doc = "0x166 - USB Receive Control and Status Endpoint 6 Low"]
        pub rxcsrl6: RXCSRL6,
        #[doc = "0x167 - USB Receive Control and Status Endpoint 6 High"]
        pub rxcsrh6: RXCSRH6,
        #[doc = "0x168 - USB Receive Byte Count Endpoint 6"]
        pub rxcount6: RXCOUNT6,
        #[doc = "0x16a - USB Host Transmit Configure Type Endpoint 6"]
        pub txtype6: TXTYPE6,
        #[doc = "0x16b - USB Host Transmit Interval Endpoint 6"]
        pub txinterval6: TXINTERVAL6,
        #[doc = "0x16c - USB Host Configure Receive Type Endpoint 6"]
        pub rxtype6: RXTYPE6,
        #[doc = "0x16d - USB Host Receive Polling Interval Endpoint 6"]
        pub rxinterval6: RXINTERVAL6,
        _reserved31: [u8; 2usize],
        #[doc = "0x170 - USB Maximum Transmit Data Endpoint 7"]
        pub txmaxp7: TXMAXP7,
        #[doc = "0x172 - USB Transmit Control and Status Endpoint 7 Low"]
        pub txcsrl7: TXCSRL7,
        #[doc = "0x173 - USB Transmit Control and Status Endpoint 7 High"]
        pub txcsrh7: TXCSRH7,
        #[doc = "0x174 - USB Maximum Receive Data Endpoint 7"]
        pub rxmaxp7: RXMAXP7,
        #[doc = "0x176 - USB Receive Control and Status Endpoint 7 Low"]
        pub rxcsrl7: RXCSRL7,
        #[doc = "0x177 - USB Receive Control and Status Endpoint 7 High"]
        pub rxcsrh7: RXCSRH7,
        #[doc = "0x178 - USB Receive Byte Count Endpoint 7"]
        pub rxcount7: RXCOUNT7,
        #[doc = "0x17a - USB Host Transmit Configure Type Endpoint 7"]
        pub txtype7: TXTYPE7,
        #[doc = "0x17b - USB Host Transmit Interval Endpoint 7"]
        pub txinterval7: TXINTERVAL7,
        #[doc = "0x17c - USB Host Configure Receive Type Endpoint 7"]
        pub rxtype7: RXTYPE7,
        #[doc = "0x17d - USB Host Receive Polling Interval Endpoint 7"]
        pub rxinterval7: RXINTERVAL7,
        _reserved32: [u8; 130usize],
        #[doc = "0x200 - USB DMA Interrupt"]
        pub dmaintr: DMAINTR,
        _reserved33: [u8; 3usize],
        #[doc = "0x204 - USB DMA Control 0"]
        pub dmactl0: DMACTL0,
        _reserved34: [u8; 2usize],
        #[doc = "0x208 - USB DMA Address 0"]
        pub dmaaddr0: DMAADDR0,
        #[doc = "0x20c - USB DMA Count 0"]
        pub dmacount0: DMACOUNT0,
        _reserved35: [u8; 4usize],
        #[doc = "0x214 - USB DMA Control 1"]
        pub dmactl1: DMACTL1,
        _reserved36: [u8; 2usize],
        #[doc = "0x218 - USB DMA Address 1"]
        pub dmaaddr1: DMAADDR1,
        #[doc = "0x21c - USB DMA Count 1"]
        pub dmacount1: DMACOUNT1,
        _reserved37: [u8; 4usize],
        #[doc = "0x224 - USB DMA Control 2"]
        pub dmactl2: DMACTL2,
        _reserved38: [u8; 2usize],
        #[doc = "0x228 - USB DMA Address 2"]
        pub dmaaddr2: DMAADDR2,
        #[doc = "0x22c - USB DMA Count 2"]
        pub dmacount2: DMACOUNT2,
        _reserved39: [u8; 4usize],
        #[doc = "0x234 - USB DMA Control 3"]
        pub dmactl3: DMACTL3,
        _reserved40: [u8; 2usize],
        #[doc = "0x238 - USB DMA Address 3"]
        pub dmaaddr3: DMAADDR3,
        #[doc = "0x23c - USB DMA Count 3"]
        pub dmacount3: DMACOUNT3,
        _reserved41: [u8; 4usize],
        #[doc = "0x244 - USB DMA Control 4"]
        pub dmactl4: DMACTL4,
        _reserved42: [u8; 2usize],
        #[doc = "0x248 - USB DMA Address 4"]
        pub dmaaddr4: DMAADDR4,
        #[doc = "0x24c - USB DMA Count 4"]
        pub dmacount4: DMACOUNT4,
        _reserved43: [u8; 4usize],
        #[doc = "0x254 - USB DMA Control 5"]
        pub dmactl5: DMACTL5,
        _reserved44: [u8; 2usize],
        #[doc = "0x258 - USB DMA Address 5"]
        pub dmaaddr5: DMAADDR5,
        #[doc = "0x25c - USB DMA Count 5"]
        pub dmacount5: DMACOUNT5,
        _reserved45: [u8; 4usize],
        #[doc = "0x264 - USB DMA Control 6"]
        pub dmactl6: DMACTL6,
        _reserved46: [u8; 2usize],
        #[doc = "0x268 - USB DMA Address 6"]
        pub dmaaddr6: DMAADDR6,
        #[doc = "0x26c - USB DMA Count 6"]
        pub dmacount6: DMACOUNT6,
        _reserved47: [u8; 4usize],
        #[doc = "0x274 - USB DMA Control 7"]
        pub dmactl7: DMACTL7,
        _reserved48: [u8; 2usize],
        #[doc = "0x278 - USB DMA Address 7"]
        pub dmaaddr7: DMAADDR7,
        #[doc = "0x27c - USB DMA Count 7"]
        pub dmacount7: DMACOUNT7,
        _reserved49: [u8; 132usize],
        #[doc = "0x304 - USB Request Packet Count in Block Transfer Endpoint 1"]
        pub rqpktcount1: RQPKTCOUNT1,
        _reserved50: [u8; 2usize],
        #[doc = "0x308 - USB Request Packet Count in Block Transfer Endpoint 2"]
        pub rqpktcount2: RQPKTCOUNT2,
        _reserved51: [u8; 2usize],
        #[doc = "0x30c - USB Request Packet Count in Block Transfer Endpoint 3"]
        pub rqpktcount3: RQPKTCOUNT3,
        _reserved52: [u8; 2usize],
        #[doc = "0x310 - USB Request Packet Count in Block Transfer Endpoint 4"]
        pub rqpktcount4: RQPKTCOUNT4,
        _reserved53: [u8; 2usize],
        #[doc = "0x314 - USB Request Packet Count in Block Transfer Endpoint 5"]
        pub rqpktcount5: RQPKTCOUNT5,
        _reserved54: [u8; 2usize],
        #[doc = "0x318 - USB Request Packet Count in Block Transfer Endpoint 6"]
        pub rqpktcount6: RQPKTCOUNT6,
        _reserved55: [u8; 2usize],
        #[doc = "0x31c - USB Request Packet Count in Block Transfer Endpoint 7"]
        pub rqpktcount7: RQPKTCOUNT7,
        _reserved56: [u8; 34usize],
        #[doc = "0x340 - USB Receive Double Packet Buffer Disable"]
        pub rxdpktbufdis: RXDPKTBUFDIS,
        #[doc = "0x342 - USB Transmit Double Packet Buffer Disable"]
        pub txdpktbufdis: TXDPKTBUFDIS,
        #[doc = "0x344 - USB Chirp Timeout"]
        pub cto: CTO,
        #[doc = "0x346 - USB High Speed to UTM Operating Delay"]
        pub hhsrtn: HHSRTN,
        #[doc = "0x348 - USB High Speed Time-out Adder"]
        pub hsbt: HSBT,
        _reserved57: [u8; 22usize],
        #[doc = "0x360 - USB LPM Attributes"]
        pub lpmattr: LPMATTR,
        #[doc = "0x362 - USB LPM Control"]
        pub lpmcntrl: LPMCNTRL,
        #[doc = "0x363 - USB LPM Interrupt Mask"]
        pub lpmim: LPMIM,
        #[doc = "0x364 - USB LPM Raw Interrupt Status"]
        pub lpmris: LPMRIS,
        #[doc = "0x365 - USB LPM Function Address"]
        pub lpmfaddr: LPMFADDR,
        _reserved58: [u8; 154usize],
        #[doc = "0x400 - USB External Power Control"]
        pub epc: EPC,
        #[doc = "0x404 - USB External Power Control Raw Interrupt Status"]
        pub epcris: EPCRIS,
        #[doc = "0x408 - USB External Power Control Interrupt Mask"]
        pub epcim: EPCIM,
        #[doc = "0x40c - USB External Power Control Interrupt Status and Clear"]
        pub epcisc: EPCISC,
        #[doc = "0x410 - USB Device RESUME Raw Interrupt Status"]
        pub drris: DRRIS,
        #[doc = "0x414 - USB Device RESUME Interrupt Mask"]
        pub drim: DRIM,
        #[doc = "0x418 - USB Device RESUME Interrupt Status and Clear"]
        pub drisc: DRISC,
        #[doc = "0x41c - USB General-Purpose Control and Status"]
        pub gpcs: GPCS,
        _reserved59: [u8; 16usize],
        #[doc = "0x430 - USB VBUS Droop Control"]
        pub vdc: VDC,
        #[doc = "0x434 - USB VBUS Droop Control Raw Interrupt Status"]
        pub vdcris: VDCRIS,
        #[doc = "0x438 - USB VBUS Droop Control Interrupt Mask"]
        pub vdcim: VDCIM,
        #[doc = "0x43c - USB VBUS Droop Control Interrupt Status and Clear"]
        pub vdcisc: VDCISC,
        _reserved60: [u8; 2944usize],
        #[doc = "0xfc0 - USB Peripheral Properties"]
        pub pp: PP,
        #[doc = "0xfc4 - USB Peripheral Configuration"]
        pub pc: PC,
        #[doc = "0xfc8 - USB Clock Configuration"]
        pub cc: CC,
    }
    #[doc = "USB Device Functional Address"]
    pub struct FADDR {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Device Functional Address"]
    pub mod faddr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::FADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FADDRR {
            bits: u8,
        }
        impl FADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Function Address"]
            #[inline]
            pub fn faddr(&self) -> FADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                FADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Function Address"]
            #[inline]
            pub fn faddr(&mut self) -> _FADDRW {
                _FADDRW { w: self }
            }
        }
    }
    #[doc = "USB Power"]
    pub struct POWER {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Power"]
    pub mod power {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::POWER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWRDNPHYR {
            bits: bool,
        }
        impl PWRDNPHYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SUSPENDR {
            bits: bool,
        }
        impl SUSPENDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESUMER {
            bits: bool,
        }
        impl RESUMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESETR {
            bits: bool,
        }
        impl RESETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSMODER {
            bits: bool,
        }
        impl HSMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSENABR {
            bits: bool,
        }
        impl HSENABR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SOFTCONNR {
            bits: bool,
        }
        impl SOFTCONNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOUPR {
            bits: bool,
        }
        impl ISOUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWRDNPHYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWRDNPHYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SUSPENDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SUSPENDW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESUMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESUMEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESETW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSMODEW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSENABW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSENABW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SOFTCONNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SOFTCONNW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOUPW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Power Down PHY"]
            #[inline]
            pub fn pwrdnphy(&self) -> PWRDNPHYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PWRDNPHYR { bits }
            }
            #[doc = "Bit 1 - SUSPEND Mode"]
            #[inline]
            pub fn suspend(&self) -> SUSPENDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SUSPENDR { bits }
            }
            #[doc = "Bit 2 - RESUME Signaling"]
            #[inline]
            pub fn resume(&self) -> RESUMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESUMER { bits }
            }
            #[doc = "Bit 3 - RESET Signaling"]
            #[inline]
            pub fn reset(&self) -> RESETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESETR { bits }
            }
            #[doc = "Bit 4 - High Speed Enable"]
            #[inline]
            pub fn hsmode(&self) -> HSMODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                HSMODER { bits }
            }
            #[doc = "Bit 5 - High Speed Enable"]
            #[inline]
            pub fn hsenab(&self) -> HSENABR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                HSENABR { bits }
            }
            #[doc = "Bit 6 - Soft Connect/Disconnect"]
            #[inline]
            pub fn softconn(&self) -> SOFTCONNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SOFTCONNR { bits }
            }
            #[doc = "Bit 7 - Isochronous Update"]
            #[inline]
            pub fn isoup(&self) -> ISOUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOUPR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Power Down PHY"]
            #[inline]
            pub fn pwrdnphy(&mut self) -> _PWRDNPHYW {
                _PWRDNPHYW { w: self }
            }
            #[doc = "Bit 1 - SUSPEND Mode"]
            #[inline]
            pub fn suspend(&mut self) -> _SUSPENDW {
                _SUSPENDW { w: self }
            }
            #[doc = "Bit 2 - RESUME Signaling"]
            #[inline]
            pub fn resume(&mut self) -> _RESUMEW {
                _RESUMEW { w: self }
            }
            #[doc = "Bit 3 - RESET Signaling"]
            #[inline]
            pub fn reset(&mut self) -> _RESETW {
                _RESETW { w: self }
            }
            #[doc = "Bit 4 - High Speed Enable"]
            #[inline]
            pub fn hsmode(&mut self) -> _HSMODEW {
                _HSMODEW { w: self }
            }
            #[doc = "Bit 5 - High Speed Enable"]
            #[inline]
            pub fn hsenab(&mut self) -> _HSENABW {
                _HSENABW { w: self }
            }
            #[doc = "Bit 6 - Soft Connect/Disconnect"]
            #[inline]
            pub fn softconn(&mut self) -> _SOFTCONNW {
                _SOFTCONNW { w: self }
            }
            #[doc = "Bit 7 - Isochronous Update"]
            #[inline]
            pub fn isoup(&mut self) -> _ISOUPW {
                _ISOUPW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Interrupt Status"]
    pub struct TXIS {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Transmit Interrupt Status"]
    pub mod txis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::TXIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP0R {
            bits: bool,
        }
        impl EP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - TX and RX Endpoint 0 Interrupt"]
            #[inline]
            pub fn ep0(&self) -> EP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP0R { bits }
            }
            #[doc = "Bit 1 - TX Endpoint 1 Interrupt"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - TX Endpoint 2 Interrupt"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - TX Endpoint 3 Interrupt"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - TX Endpoint 4 Interrupt"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - TX Endpoint 5 Interrupt"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - TX Endpoint 6 Interrupt"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - TX Endpoint 7 Interrupt"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
    }
    #[doc = "USB Receive Interrupt Status"]
    pub struct RXIS {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Interrupt Status"]
    pub mod rxis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 1 - RX Endpoint 1 Interrupt"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - RX Endpoint 2 Interrupt"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - RX Endpoint 3 Interrupt"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - RX Endpoint 4 Interrupt"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - RX Endpoint 5 Interrupt"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - RX Endpoint 6 Interrupt"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - RX Endpoint 7 Interrupt"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
    }
    #[doc = "USB Transmit Interrupt Enable"]
    pub struct TXIE {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Transmit Interrupt Enable"]
    pub mod txie {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXIE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP0R {
            bits: bool,
        }
        impl EP0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP0W<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP1W<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP2W<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP3W<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP4W<'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 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP5W<'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 = 5;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP6W<'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 = 6;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP7W<'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 = 7;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - TX and RX Endpoint 0 Interrupt Enable"]
            #[inline]
            pub fn ep0(&self) -> EP0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP0R { bits }
            }
            #[doc = "Bit 1 - TX Endpoint 1 Interrupt Enable"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - TX Endpoint 2 Interrupt Enable"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - TX Endpoint 3 Interrupt Enable"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - TX Endpoint 4 Interrupt Enable"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - TX Endpoint 5 Interrupt Enable"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - TX Endpoint 6 Interrupt Enable"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - TX Endpoint 7 Interrupt Enable"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - TX and RX Endpoint 0 Interrupt Enable"]
            #[inline]
            pub fn ep0(&mut self) -> _EP0W {
                _EP0W { w: self }
            }
            #[doc = "Bit 1 - TX Endpoint 1 Interrupt Enable"]
            #[inline]
            pub fn ep1(&mut self) -> _EP1W {
                _EP1W { w: self }
            }
            #[doc = "Bit 2 - TX Endpoint 2 Interrupt Enable"]
            #[inline]
            pub fn ep2(&mut self) -> _EP2W {
                _EP2W { w: self }
            }
            #[doc = "Bit 3 - TX Endpoint 3 Interrupt Enable"]
            #[inline]
            pub fn ep3(&mut self) -> _EP3W {
                _EP3W { w: self }
            }
            #[doc = "Bit 4 - TX Endpoint 4 Interrupt Enable"]
            #[inline]
            pub fn ep4(&mut self) -> _EP4W {
                _EP4W { w: self }
            }
            #[doc = "Bit 5 - TX Endpoint 5 Interrupt Enable"]
            #[inline]
            pub fn ep5(&mut self) -> _EP5W {
                _EP5W { w: self }
            }
            #[doc = "Bit 6 - TX Endpoint 6 Interrupt Enable"]
            #[inline]
            pub fn ep6(&mut self) -> _EP6W {
                _EP6W { w: self }
            }
            #[doc = "Bit 7 - TX Endpoint 7 Interrupt Enable"]
            #[inline]
            pub fn ep7(&mut self) -> _EP7W {
                _EP7W { w: self }
            }
        }
    }
    #[doc = "USB Receive Interrupt Enable"]
    pub struct RXIE {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Interrupt Enable"]
    pub mod rxie {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXIE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP1W<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP2W<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP3W<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP4W<'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 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP5W<'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 = 5;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP6W<'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 = 6;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP7W<'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 = 7;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 1 - RX Endpoint 1 Interrupt Enable"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - RX Endpoint 2 Interrupt Enable"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - RX Endpoint 3 Interrupt Enable"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - RX Endpoint 4 Interrupt Enable"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - RX Endpoint 5 Interrupt Enable"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - RX Endpoint 6 Interrupt Enable"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - RX Endpoint 7 Interrupt Enable"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 1 - RX Endpoint 1 Interrupt Enable"]
            #[inline]
            pub fn ep1(&mut self) -> _EP1W {
                _EP1W { w: self }
            }
            #[doc = "Bit 2 - RX Endpoint 2 Interrupt Enable"]
            #[inline]
            pub fn ep2(&mut self) -> _EP2W {
                _EP2W { w: self }
            }
            #[doc = "Bit 3 - RX Endpoint 3 Interrupt Enable"]
            #[inline]
            pub fn ep3(&mut self) -> _EP3W {
                _EP3W { w: self }
            }
            #[doc = "Bit 4 - RX Endpoint 4 Interrupt Enable"]
            #[inline]
            pub fn ep4(&mut self) -> _EP4W {
                _EP4W { w: self }
            }
            #[doc = "Bit 5 - RX Endpoint 5 Interrupt Enable"]
            #[inline]
            pub fn ep5(&mut self) -> _EP5W {
                _EP5W { w: self }
            }
            #[doc = "Bit 6 - RX Endpoint 6 Interrupt Enable"]
            #[inline]
            pub fn ep6(&mut self) -> _EP6W {
                _EP6W { w: self }
            }
            #[doc = "Bit 7 - RX Endpoint 7 Interrupt Enable"]
            #[inline]
            pub fn ep7(&mut self) -> _EP7W {
                _EP7W { w: self }
            }
        }
    }
    #[doc = "USB General Interrupt Status"]
    pub struct IS {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB General Interrupt Status"]
    pub mod is {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::IS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct SUSPENDR {
            bits: bool,
        }
        impl SUSPENDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESUMER {
            bits: bool,
        }
        impl RESUMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BABBLER {
            bits: bool,
        }
        impl BABBLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESETR {
            bits: bool,
        }
        impl RESETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SOFR {
            bits: bool,
        }
        impl SOFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CONNR {
            bits: bool,
        }
        impl CONNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISCONR {
            bits: bool,
        }
        impl DISCONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SESREQR {
            bits: bool,
        }
        impl SESREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VBUSERRR {
            bits: bool,
        }
        impl VBUSERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - SUSPEND Signaling Detected"]
            #[inline]
            pub fn suspend(&self) -> SUSPENDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SUSPENDR { bits }
            }
            #[doc = "Bit 1 - RESUME Signaling Detected"]
            #[inline]
            pub fn resume(&self) -> RESUMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESUMER { bits }
            }
            #[doc = "Bit 2 - Babble Detected"]
            #[inline]
            pub fn babble(&self) -> BABBLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                BABBLER { bits }
            }
            #[doc = "Bit 2 - RESET Signaling Detected"]
            #[inline]
            pub fn reset(&self) -> RESETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESETR { bits }
            }
            #[doc = "Bit 3 - Start of Frame"]
            #[inline]
            pub fn sof(&self) -> SOFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SOFR { bits }
            }
            #[doc = "Bit 4 - Session Connect"]
            #[inline]
            pub fn conn(&self) -> CONNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CONNR { bits }
            }
            #[doc = "Bit 5 - Session Disconnect (OTG only)"]
            #[inline]
            pub fn discon(&self) -> DISCONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISCONR { bits }
            }
            #[doc = "Bit 6 - SESSION REQUEST (OTG only)"]
            #[inline]
            pub fn sesreq(&self) -> SESREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SESREQR { bits }
            }
            #[doc = "Bit 7 - VBUS Error (OTG only)"]
            #[inline]
            pub fn vbuserr(&self) -> VBUSERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                VBUSERRR { bits }
            }
        }
    }
    #[doc = "USB Interrupt Enable"]
    pub struct IE {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Interrupt Enable"]
    pub mod ie {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::IE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SUSPNDR {
            bits: bool,
        }
        impl SUSPNDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESUMER {
            bits: bool,
        }
        impl RESUMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BABBLER {
            bits: bool,
        }
        impl BABBLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESETR {
            bits: bool,
        }
        impl RESETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SOFR {
            bits: bool,
        }
        impl SOFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CONNR {
            bits: bool,
        }
        impl CONNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISCONR {
            bits: bool,
        }
        impl DISCONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SESREQR {
            bits: bool,
        }
        impl SESREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VBUSERRR {
            bits: bool,
        }
        impl VBUSERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SUSPNDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SUSPNDW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESUMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESUMEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BABBLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BABBLEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESETW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SOFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SOFW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CONNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CONNW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISCONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISCONW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SESREQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SESREQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VBUSERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VBUSERRW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Enable SUSPEND Interrupt"]
            #[inline]
            pub fn suspnd(&self) -> SUSPNDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SUSPNDR { bits }
            }
            #[doc = "Bit 1 - Enable RESUME Interrupt"]
            #[inline]
            pub fn resume(&self) -> RESUMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESUMER { bits }
            }
            #[doc = "Bit 2 - Enable Babble Interrupt"]
            #[inline]
            pub fn babble(&self) -> BABBLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                BABBLER { bits }
            }
            #[doc = "Bit 2 - Enable RESET Interrupt"]
            #[inline]
            pub fn reset(&self) -> RESETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESETR { bits }
            }
            #[doc = "Bit 3 - Enable Start-of-Frame Interrupt"]
            #[inline]
            pub fn sof(&self) -> SOFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SOFR { bits }
            }
            #[doc = "Bit 4 - Enable Connect Interrupt"]
            #[inline]
            pub fn conn(&self) -> CONNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CONNR { bits }
            }
            #[doc = "Bit 5 - Enable Disconnect Interrupt"]
            #[inline]
            pub fn discon(&self) -> DISCONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISCONR { bits }
            }
            #[doc = "Bit 6 - Enable Session Request (OTG only)"]
            #[inline]
            pub fn sesreq(&self) -> SESREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SESREQR { bits }
            }
            #[doc = "Bit 7 - Enable VBUS Error Interrupt (OTG only)"]
            #[inline]
            pub fn vbuserr(&self) -> VBUSERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                VBUSERRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Enable SUSPEND Interrupt"]
            #[inline]
            pub fn suspnd(&mut self) -> _SUSPNDW {
                _SUSPNDW { w: self }
            }
            #[doc = "Bit 1 - Enable RESUME Interrupt"]
            #[inline]
            pub fn resume(&mut self) -> _RESUMEW {
                _RESUMEW { w: self }
            }
            #[doc = "Bit 2 - Enable Babble Interrupt"]
            #[inline]
            pub fn babble(&mut self) -> _BABBLEW {
                _BABBLEW { w: self }
            }
            #[doc = "Bit 2 - Enable RESET Interrupt"]
            #[inline]
            pub fn reset(&mut self) -> _RESETW {
                _RESETW { w: self }
            }
            #[doc = "Bit 3 - Enable Start-of-Frame Interrupt"]
            #[inline]
            pub fn sof(&mut self) -> _SOFW {
                _SOFW { w: self }
            }
            #[doc = "Bit 4 - Enable Connect Interrupt"]
            #[inline]
            pub fn conn(&mut self) -> _CONNW {
                _CONNW { w: self }
            }
            #[doc = "Bit 5 - Enable Disconnect Interrupt"]
            #[inline]
            pub fn discon(&mut self) -> _DISCONW {
                _DISCONW { w: self }
            }
            #[doc = "Bit 6 - Enable Session Request (OTG only)"]
            #[inline]
            pub fn sesreq(&mut self) -> _SESREQW {
                _SESREQW { w: self }
            }
            #[doc = "Bit 7 - Enable VBUS Error Interrupt (OTG only)"]
            #[inline]
            pub fn vbuserr(&mut self) -> _VBUSERRW {
                _VBUSERRW { w: self }
            }
        }
    }
    #[doc = "USB Frame Value"]
    pub struct FRAME {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Frame Value"]
    pub mod frame {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::FRAME {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FRAMER {
            bits: u16,
        }
        impl FRAMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Frame Number"]
            #[inline]
            pub fn frame(&self) -> FRAMER {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                FRAMER { bits }
            }
        }
    }
    #[doc = "USB Endpoint Index"]
    pub struct EPIDX {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Endpoint Index"]
    pub mod epidx {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::EPIDX {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPIDXR {
            bits: u8,
        }
        impl EPIDXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPIDXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPIDXW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Endpoint Index"]
            #[inline]
            pub fn epidx(&self) -> EPIDXR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                EPIDXR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Endpoint Index"]
            #[inline]
            pub fn epidx(&mut self) -> _EPIDXW {
                _EPIDXW { w: self }
            }
        }
    }
    #[doc = "USB Test Mode"]
    pub struct TEST {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Test Mode"]
    pub mod test {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TEST {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TESTSE0NAKR {
            bits: bool,
        }
        impl TESTSE0NAKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TESTJR {
            bits: bool,
        }
        impl TESTJR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TESTKR {
            bits: bool,
        }
        impl TESTKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TESTPKTR {
            bits: bool,
        }
        impl TESTPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FORCEHSR {
            bits: bool,
        }
        impl FORCEHSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FORCEFSR {
            bits: bool,
        }
        impl FORCEFSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFOACCR {
            bits: bool,
        }
        impl FIFOACCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FORCEHR {
            bits: bool,
        }
        impl FORCEHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TESTSE0NAKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TESTSE0NAKW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TESTJW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TESTJW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TESTKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TESTKW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TESTPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TESTPKTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FORCEHSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FORCEHSW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FORCEFSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FORCEFSW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFOACCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFOACCW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FORCEHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FORCEHW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Test_SE0_NAK Test Mode Enable"]
            #[inline]
            pub fn testse0nak(&self) -> TESTSE0NAKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TESTSE0NAKR { bits }
            }
            #[doc = "Bit 1 - Test_J Mode Enable"]
            #[inline]
            pub fn testj(&self) -> TESTJR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TESTJR { bits }
            }
            #[doc = "Bit 2 - Test_K Mode Enable"]
            #[inline]
            pub fn testk(&self) -> TESTKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TESTKR { bits }
            }
            #[doc = "Bit 3 - Test Packet Mode Enable"]
            #[inline]
            pub fn testpkt(&self) -> TESTPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TESTPKTR { bits }
            }
            #[doc = "Bit 4 - Force High-Speed Mode"]
            #[inline]
            pub fn forcehs(&self) -> FORCEHSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FORCEHSR { bits }
            }
            #[doc = "Bit 5 - Force Full-Speed Mode"]
            #[inline]
            pub fn forcefs(&self) -> FORCEFSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FORCEFSR { bits }
            }
            #[doc = "Bit 6 - FIFO Access"]
            #[inline]
            pub fn fifoacc(&self) -> FIFOACCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFOACCR { bits }
            }
            #[doc = "Bit 7 - Force Host Mode"]
            #[inline]
            pub fn forceh(&self) -> FORCEHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FORCEHR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Test_SE0_NAK Test Mode Enable"]
            #[inline]
            pub fn testse0nak(&mut self) -> _TESTSE0NAKW {
                _TESTSE0NAKW { w: self }
            }
            #[doc = "Bit 1 - Test_J Mode Enable"]
            #[inline]
            pub fn testj(&mut self) -> _TESTJW {
                _TESTJW { w: self }
            }
            #[doc = "Bit 2 - Test_K Mode Enable"]
            #[inline]
            pub fn testk(&mut self) -> _TESTKW {
                _TESTKW { w: self }
            }
            #[doc = "Bit 3 - Test Packet Mode Enable"]
            #[inline]
            pub fn testpkt(&mut self) -> _TESTPKTW {
                _TESTPKTW { w: self }
            }
            #[doc = "Bit 4 - Force High-Speed Mode"]
            #[inline]
            pub fn forcehs(&mut self) -> _FORCEHSW {
                _FORCEHSW { w: self }
            }
            #[doc = "Bit 5 - Force Full-Speed Mode"]
            #[inline]
            pub fn forcefs(&mut self) -> _FORCEFSW {
                _FORCEFSW { w: self }
            }
            #[doc = "Bit 6 - FIFO Access"]
            #[inline]
            pub fn fifoacc(&mut self) -> _FIFOACCW {
                _FIFOACCW { w: self }
            }
            #[doc = "Bit 7 - Force Host Mode"]
            #[inline]
            pub fn forceh(&mut self) -> _FORCEHW {
                _FORCEHW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 0"]
    pub struct FIFO0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 0"]
    pub mod fifo0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 1"]
    pub struct FIFO1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 1"]
    pub mod fifo1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 2"]
    pub struct FIFO2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 2"]
    pub mod fifo2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 3"]
    pub struct FIFO3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 3"]
    pub mod fifo3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 4"]
    pub struct FIFO4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 4"]
    pub mod fifo4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 5"]
    pub struct FIFO5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 5"]
    pub mod fifo5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 6"]
    pub struct FIFO6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 6"]
    pub mod fifo6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB FIFO Endpoint 7"]
    pub struct FIFO7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB FIFO Endpoint 7"]
    pub mod fifo7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFO7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPDATAR {
            bits: u32,
        }
        impl EPDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&self) -> EPDATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                EPDATAR { bits }
            }
        }
        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 0:31 - Endpoint Data"]
            #[inline]
            pub fn epdata(&mut self) -> _EPDATAW {
                _EPDATAW { w: self }
            }
        }
    }
    #[doc = "USB Device Control"]
    pub struct DEVCTL {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Device Control"]
    pub mod devctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::DEVCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SESSIONR {
            bits: bool,
        }
        impl SESSIONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HOSTREQR {
            bits: bool,
        }
        impl HOSTREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HOSTR {
            bits: bool,
        }
        impl HOSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `VBUS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VBUSR {
            #[doc = "Below SessionEnd"]
            NONE,
            #[doc = "Above SessionEnd, below AValid"]
            SEND,
            #[doc = "Above AValid, below VBUSValid"]
            AVALID,
            #[doc = "Above VBUSValid"]
            VALID,
        }
        impl VBUSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VBUSR::NONE => 0,
                    VBUSR::SEND => 0x01,
                    VBUSR::AVALID => 0x02,
                    VBUSR::VALID => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VBUSR {
                match value {
                    0 => VBUSR::NONE,
                    1 => VBUSR::SEND,
                    2 => VBUSR::AVALID,
                    3 => VBUSR::VALID,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == VBUSR::NONE
            }
            #[doc = "Checks if the value of the field is `SEND`"]
            #[inline]
            pub fn is_send(&self) -> bool {
                *self == VBUSR::SEND
            }
            #[doc = "Checks if the value of the field is `AVALID`"]
            #[inline]
            pub fn is_avalid(&self) -> bool {
                *self == VBUSR::AVALID
            }
            #[doc = "Checks if the value of the field is `VALID`"]
            #[inline]
            pub fn is_valid(&self) -> bool {
                *self == VBUSR::VALID
            }
        }
        #[doc = r" Value of the field"]
        pub struct LSDEVR {
            bits: bool,
        }
        impl LSDEVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FSDEVR {
            bits: bool,
        }
        impl FSDEVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DEVR {
            bits: bool,
        }
        impl DEVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SESSIONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SESSIONW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HOSTREQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HOSTREQW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HOSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HOSTW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `VBUS`"]
        pub enum VBUSW {
            #[doc = "Below SessionEnd"]
            NONE,
            #[doc = "Above SessionEnd, below AValid"]
            SEND,
            #[doc = "Above AValid, below VBUSValid"]
            AVALID,
            #[doc = "Above VBUSValid"]
            VALID,
        }
        impl VBUSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VBUSW::NONE => 0,
                    VBUSW::SEND => 1,
                    VBUSW::AVALID => 2,
                    VBUSW::VALID => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VBUSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VBUSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VBUSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Below SessionEnd"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(VBUSW::NONE)
            }
            #[doc = "Above SessionEnd, below AValid"]
            #[inline]
            pub fn send(self) -> &'a mut W {
                self.variant(VBUSW::SEND)
            }
            #[doc = "Above AValid, below VBUSValid"]
            #[inline]
            pub fn avalid(self) -> &'a mut W {
                self.variant(VBUSW::AVALID)
            }
            #[doc = "Above VBUSValid"]
            #[inline]
            pub fn valid(self) -> &'a mut W {
                self.variant(VBUSW::VALID)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LSDEVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LSDEVW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FSDEVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FSDEVW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEVW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Session Start/End (OTG only)"]
            #[inline]
            pub fn session(&self) -> SESSIONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SESSIONR { bits }
            }
            #[doc = "Bit 1 - Host Request (OTG only)"]
            #[inline]
            pub fn hostreq(&self) -> HOSTREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                HOSTREQR { bits }
            }
            #[doc = "Bit 2 - Host Mode"]
            #[inline]
            pub fn host(&self) -> HOSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                HOSTR { bits }
            }
            #[doc = "Bits 3:4 - VBUS Level (OTG only)"]
            #[inline]
            pub fn vbus(&self) -> VBUSR {
                VBUSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bit 5 - Low-Speed Device Detected"]
            #[inline]
            pub fn lsdev(&self) -> LSDEVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                LSDEVR { bits }
            }
            #[doc = "Bit 6 - Full-Speed Device Detected"]
            #[inline]
            pub fn fsdev(&self) -> FSDEVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FSDEVR { bits }
            }
            #[doc = "Bit 7 - Device Mode (OTG only)"]
            #[inline]
            pub fn dev(&self) -> DEVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DEVR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Session Start/End (OTG only)"]
            #[inline]
            pub fn session(&mut self) -> _SESSIONW {
                _SESSIONW { w: self }
            }
            #[doc = "Bit 1 - Host Request (OTG only)"]
            #[inline]
            pub fn hostreq(&mut self) -> _HOSTREQW {
                _HOSTREQW { w: self }
            }
            #[doc = "Bit 2 - Host Mode"]
            #[inline]
            pub fn host(&mut self) -> _HOSTW {
                _HOSTW { w: self }
            }
            #[doc = "Bits 3:4 - VBUS Level (OTG only)"]
            #[inline]
            pub fn vbus(&mut self) -> _VBUSW {
                _VBUSW { w: self }
            }
            #[doc = "Bit 5 - Low-Speed Device Detected"]
            #[inline]
            pub fn lsdev(&mut self) -> _LSDEVW {
                _LSDEVW { w: self }
            }
            #[doc = "Bit 6 - Full-Speed Device Detected"]
            #[inline]
            pub fn fsdev(&mut self) -> _FSDEVW {
                _FSDEVW { w: self }
            }
            #[doc = "Bit 7 - Device Mode (OTG only)"]
            #[inline]
            pub fn dev(&mut self) -> _DEVW {
                _DEVW { w: self }
            }
        }
    }
    #[doc = "USB Common Configuration"]
    pub struct CCONF {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Common Configuration"]
    pub mod cconf {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::CCONF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXEDMAR {
            bits: bool,
        }
        impl RXEDMAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXEDMAR {
            bits: bool,
        }
        impl TXEDMAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXEDMAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXEDMAW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXEDMAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXEDMAW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - TX Early DMA Enable"]
            #[inline]
            pub fn rxedma(&self) -> RXEDMAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXEDMAR { bits }
            }
            #[doc = "Bit 1 - TX Early DMA Enable"]
            #[inline]
            pub fn txedma(&self) -> TXEDMAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXEDMAR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - TX Early DMA Enable"]
            #[inline]
            pub fn rxedma(&mut self) -> _RXEDMAW {
                _RXEDMAW { w: self }
            }
            #[doc = "Bit 1 - TX Early DMA Enable"]
            #[inline]
            pub fn txedma(&mut self) -> _TXEDMAW {
                _TXEDMAW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Dynamic FIFO Sizing"]
    pub struct TXFIFOSZ {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Dynamic FIFO Sizing"]
    pub mod txfifosz {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFIFOSZ {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "8"]
            _8,
            #[doc = "16"]
            _16,
            #[doc = "32"]
            _32,
            #[doc = "64"]
            _64,
            #[doc = "128"]
            _128,
            #[doc = "256"]
            _256,
            #[doc = "512"]
            _512,
            #[doc = "1024"]
            _1024,
            #[doc = "2048"]
            _2048,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_8 => 0,
                    SIZER::_16 => 0x01,
                    SIZER::_32 => 0x02,
                    SIZER::_64 => 0x03,
                    SIZER::_128 => 0x04,
                    SIZER::_256 => 0x05,
                    SIZER::_512 => 0x06,
                    SIZER::_1024 => 0x07,
                    SIZER::_2048 => 0x08,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    0 => SIZER::_8,
                    1 => SIZER::_16,
                    2 => SIZER::_32,
                    3 => SIZER::_64,
                    4 => SIZER::_128,
                    5 => SIZER::_256,
                    6 => SIZER::_512,
                    7 => SIZER::_1024,
                    8 => SIZER::_2048,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == SIZER::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == SIZER::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == SIZER::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == SIZER::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == SIZER::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == SIZER::_256
            }
            #[doc = "Checks if the value of the field is `_512`"]
            #[inline]
            pub fn is_512(&self) -> bool {
                *self == SIZER::_512
            }
            #[doc = "Checks if the value of the field is `_1024`"]
            #[inline]
            pub fn is_1024(&self) -> bool {
                *self == SIZER::_1024
            }
            #[doc = "Checks if the value of the field is `_2048`"]
            #[inline]
            pub fn is_2048(&self) -> bool {
                *self == SIZER::_2048
            }
        }
        #[doc = r" Value of the field"]
        pub struct DPBR {
            bits: bool,
        }
        impl DPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `SIZE`"]
        pub enum SIZEW {
            #[doc = "8"]
            _8,
            #[doc = "16"]
            _16,
            #[doc = "32"]
            _32,
            #[doc = "64"]
            _64,
            #[doc = "128"]
            _128,
            #[doc = "256"]
            _256,
            #[doc = "512"]
            _512,
            #[doc = "1024"]
            _1024,
            #[doc = "2048"]
            _2048,
        }
        impl SIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SIZEW::_8 => 0,
                    SIZEW::_16 => 1,
                    SIZEW::_32 => 2,
                    SIZEW::_64 => 3,
                    SIZEW::_128 => 4,
                    SIZEW::_256 => 5,
                    SIZEW::_512 => 6,
                    SIZEW::_1024 => 7,
                    SIZEW::_2048 => 8,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SIZEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(SIZEW::_8)
            }
            #[doc = "16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(SIZEW::_16)
            }
            #[doc = "32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(SIZEW::_32)
            }
            #[doc = "64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(SIZEW::_64)
            }
            #[doc = "128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(SIZEW::_128)
            }
            #[doc = "256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(SIZEW::_256)
            }
            #[doc = "512"]
            #[inline]
            pub fn _512(self) -> &'a mut W {
                self.variant(SIZEW::_512)
            }
            #[doc = "1024"]
            #[inline]
            pub fn _1024(self) -> &'a mut W {
                self.variant(SIZEW::_1024)
            }
            #[doc = "2048"]
            #[inline]
            pub fn _2048(self) -> &'a mut W {
                self.variant(SIZEW::_2048)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DPBW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Max Packet Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bit 4 - Double Packet Buffer Support"]
            #[inline]
            pub fn dpb(&self) -> DPBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DPBR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Max Packet Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
            #[doc = "Bit 4 - Double Packet Buffer Support"]
            #[inline]
            pub fn dpb(&mut self) -> _DPBW {
                _DPBW { w: self }
            }
        }
    }
    #[doc = "USB Receive Dynamic FIFO Sizing"]
    pub struct RXFIFOSZ {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Dynamic FIFO Sizing"]
    pub mod rxfifosz {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFIFOSZ {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "8"]
            _8,
            #[doc = "16"]
            _16,
            #[doc = "32"]
            _32,
            #[doc = "64"]
            _64,
            #[doc = "128"]
            _128,
            #[doc = "256"]
            _256,
            #[doc = "512"]
            _512,
            #[doc = "1024"]
            _1024,
            #[doc = "2048"]
            _2048,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_8 => 0,
                    SIZER::_16 => 0x01,
                    SIZER::_32 => 0x02,
                    SIZER::_64 => 0x03,
                    SIZER::_128 => 0x04,
                    SIZER::_256 => 0x05,
                    SIZER::_512 => 0x06,
                    SIZER::_1024 => 0x07,
                    SIZER::_2048 => 0x08,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    0 => SIZER::_8,
                    1 => SIZER::_16,
                    2 => SIZER::_32,
                    3 => SIZER::_64,
                    4 => SIZER::_128,
                    5 => SIZER::_256,
                    6 => SIZER::_512,
                    7 => SIZER::_1024,
                    8 => SIZER::_2048,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == SIZER::_8
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == SIZER::_16
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == SIZER::_32
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == SIZER::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == SIZER::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == SIZER::_256
            }
            #[doc = "Checks if the value of the field is `_512`"]
            #[inline]
            pub fn is_512(&self) -> bool {
                *self == SIZER::_512
            }
            #[doc = "Checks if the value of the field is `_1024`"]
            #[inline]
            pub fn is_1024(&self) -> bool {
                *self == SIZER::_1024
            }
            #[doc = "Checks if the value of the field is `_2048`"]
            #[inline]
            pub fn is_2048(&self) -> bool {
                *self == SIZER::_2048
            }
        }
        #[doc = r" Value of the field"]
        pub struct DPBR {
            bits: bool,
        }
        impl DPBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `SIZE`"]
        pub enum SIZEW {
            #[doc = "8"]
            _8,
            #[doc = "16"]
            _16,
            #[doc = "32"]
            _32,
            #[doc = "64"]
            _64,
            #[doc = "128"]
            _128,
            #[doc = "256"]
            _256,
            #[doc = "512"]
            _512,
            #[doc = "1024"]
            _1024,
            #[doc = "2048"]
            _2048,
        }
        impl SIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SIZEW::_8 => 0,
                    SIZEW::_16 => 1,
                    SIZEW::_32 => 2,
                    SIZEW::_64 => 3,
                    SIZEW::_128 => 4,
                    SIZEW::_256 => 5,
                    SIZEW::_512 => 6,
                    SIZEW::_1024 => 7,
                    SIZEW::_2048 => 8,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SIZEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "8"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(SIZEW::_8)
            }
            #[doc = "16"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(SIZEW::_16)
            }
            #[doc = "32"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(SIZEW::_32)
            }
            #[doc = "64"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(SIZEW::_64)
            }
            #[doc = "128"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(SIZEW::_128)
            }
            #[doc = "256"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(SIZEW::_256)
            }
            #[doc = "512"]
            #[inline]
            pub fn _512(self) -> &'a mut W {
                self.variant(SIZEW::_512)
            }
            #[doc = "1024"]
            #[inline]
            pub fn _1024(self) -> &'a mut W {
                self.variant(SIZEW::_1024)
            }
            #[doc = "2048"]
            #[inline]
            pub fn _2048(self) -> &'a mut W {
                self.variant(SIZEW::_2048)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DPBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DPBW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Max Packet Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bit 4 - Double Packet Buffer Support"]
            #[inline]
            pub fn dpb(&self) -> DPBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DPBR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Max Packet Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
            #[doc = "Bit 4 - Double Packet Buffer Support"]
            #[inline]
            pub fn dpb(&mut self) -> _DPBW {
                _DPBW { w: self }
            }
        }
    }
    #[doc = "USB Transmit FIFO Start Address"]
    pub struct TXFIFOADD {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Transmit FIFO Start Address"]
    pub mod txfifoadd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXFIFOADD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u16,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x01ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:8 - Transmit/Receive Start Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u16 = 0x01ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                ADDRR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:8 - Transmit/Receive Start Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive FIFO Start Address"]
    pub struct RXFIFOADD {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive FIFO Start Address"]
    pub mod rxfifoadd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXFIFOADD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u16,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x01ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:8 - Transmit/Receive Start Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u16 = 0x01ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                ADDRR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:8 - Transmit/Receive Start Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB ULPI VBUS Control"]
    pub struct ULPIVBUSCTL {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB ULPI VBUS Control"]
    pub mod ulpivbusctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::ULPIVBUSCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct USEEXTVBUSR {
            bits: bool,
        }
        impl USEEXTVBUSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct USEEXTVBUSINDR {
            bits: bool,
        }
        impl USEEXTVBUSINDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _USEEXTVBUSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _USEEXTVBUSW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _USEEXTVBUSINDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _USEEXTVBUSINDW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Use External VBUS"]
            #[inline]
            pub fn useextvbus(&self) -> USEEXTVBUSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                USEEXTVBUSR { bits }
            }
            #[doc = "Bit 1 - Use External VBUS Indicator"]
            #[inline]
            pub fn useextvbusind(&self) -> USEEXTVBUSINDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                USEEXTVBUSINDR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Use External VBUS"]
            #[inline]
            pub fn useextvbus(&mut self) -> _USEEXTVBUSW {
                _USEEXTVBUSW { w: self }
            }
            #[doc = "Bit 1 - Use External VBUS Indicator"]
            #[inline]
            pub fn useextvbusind(&mut self) -> _USEEXTVBUSINDW {
                _USEEXTVBUSINDW { w: self }
            }
        }
    }
    #[doc = "USB ULPI Register Data"]
    pub struct ULPIREGDATA {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB ULPI Register Data"]
    pub mod ulpiregdata {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::ULPIREGDATA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct REGDATAR {
            bits: u8,
        }
        impl REGDATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _REGDATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REGDATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - Register Data"]
            #[inline]
            pub fn regdata(&self) -> REGDATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                REGDATAR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - Register Data"]
            #[inline]
            pub fn regdata(&mut self) -> _REGDATAW {
                _REGDATAW { w: self }
            }
        }
    }
    #[doc = "USB ULPI Register Address"]
    pub struct ULPIREGADDR {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB ULPI Register Address"]
    pub mod ulpiregaddr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::ULPIREGADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - Register Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - Register Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB ULPI Register Control"]
    pub struct ULPIREGCTL {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB ULPI Register Control"]
    pub mod ulpiregctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::ULPIREGCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct REGACCR {
            bits: bool,
        }
        impl REGACCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REGCMPLTR {
            bits: bool,
        }
        impl REGCMPLTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWRR {
            bits: bool,
        }
        impl RDWRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _REGACCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REGACCW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REGCMPLTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REGCMPLTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWRW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Initiate Register Access"]
            #[inline]
            pub fn regacc(&self) -> REGACCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REGACCR { bits }
            }
            #[doc = "Bit 1 - Register Access Complete"]
            #[inline]
            pub fn regcmplt(&self) -> REGCMPLTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REGCMPLTR { bits }
            }
            #[doc = "Bit 2 - Read/Write Control"]
            #[inline]
            pub fn rdwr(&self) -> RDWRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RDWRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Initiate Register Access"]
            #[inline]
            pub fn regacc(&mut self) -> _REGACCW {
                _REGACCW { w: self }
            }
            #[doc = "Bit 1 - Register Access Complete"]
            #[inline]
            pub fn regcmplt(&mut self) -> _REGCMPLTW {
                _REGCMPLTW { w: self }
            }
            #[doc = "Bit 2 - Read/Write Control"]
            #[inline]
            pub fn rdwr(&mut self) -> _RDWRW {
                _RDWRW { w: self }
            }
        }
    }
    #[doc = "USB Endpoint Information"]
    pub struct EPINFO {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Endpoint Information"]
    pub mod epinfo {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::EPINFO {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXEPR {
            bits: u8,
        }
        impl TXEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXEPR {
            bits: u8,
        }
        impl RXEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - TX Endpoints"]
            #[inline]
            pub fn txep(&self) -> TXEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXEPR { bits }
            }
            #[doc = "Bits 4:7 - RX Endpoints"]
            #[inline]
            pub fn rxep(&self) -> RXEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                RXEPR { bits }
            }
        }
    }
    #[doc = "USB RAM Information"]
    pub struct RAMINFO {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB RAM Information"]
    pub mod raminfo {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::RAMINFO {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RAMBITSR {
            bits: u8,
        }
        impl RAMBITSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMACHANR {
            bits: u8,
        }
        impl DMACHANR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - RAM Address Bus Width"]
            #[inline]
            pub fn rambits(&self) -> RAMBITSR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                RAMBITSR { bits }
            }
            #[doc = "Bits 4:7 - DMA Channels"]
            #[inline]
            pub fn dmachan(&self) -> DMACHANR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                DMACHANR { bits }
            }
        }
    }
    #[doc = "USB Connect Timing"]
    pub struct CONTIM {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Connect Timing"]
    pub mod contim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::CONTIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WTIDR {
            bits: u8,
        }
        impl WTIDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct WTCONR {
            bits: u8,
        }
        impl WTCONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _WTIDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WTIDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WTCONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WTCONW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Wait ID"]
            #[inline]
            pub fn wtid(&self) -> WTIDR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                WTIDR { bits }
            }
            #[doc = "Bits 4:7 - Connect Wait"]
            #[inline]
            pub fn wtcon(&self) -> WTCONR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                WTCONR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Wait ID"]
            #[inline]
            pub fn wtid(&mut self) -> _WTIDW {
                _WTIDW { w: self }
            }
            #[doc = "Bits 4:7 - Connect Wait"]
            #[inline]
            pub fn wtcon(&mut self) -> _WTCONW {
                _WTCONW { w: self }
            }
        }
    }
    #[doc = "USB OTG VBUS Pulse Timing"]
    pub struct VPLEN {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB OTG VBUS Pulse Timing"]
    pub mod vplen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::VPLEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VPLENR {
            bits: u8,
        }
        impl VPLENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _VPLENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VPLENW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - VBUS Pulse Length"]
            #[inline]
            pub fn vplen(&self) -> VPLENR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                VPLENR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - VBUS Pulse Length"]
            #[inline]
            pub fn vplen(&mut self) -> _VPLENW {
                _VPLENW { w: self }
            }
        }
    }
    #[doc = "USB High-Speed Last Transaction to End of Frame Timing"]
    pub struct HSEOF {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB High-Speed Last Transaction to End of Frame Timing"]
    pub mod hseof {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::HSEOF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSEOFGR {
            bits: u8,
        }
        impl HSEOFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSEOFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSEOFGW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - HIgh-Speed End-of-Frame Gap"]
            #[inline]
            pub fn hseofg(&self) -> HSEOFGR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                HSEOFGR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - HIgh-Speed End-of-Frame Gap"]
            #[inline]
            pub fn hseofg(&mut self) -> _HSEOFGW {
                _HSEOFGW { w: self }
            }
        }
    }
    #[doc = "USB Full-Speed Last Transaction to End of Frame Timing"]
    pub struct FSEOF {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Full-Speed Last Transaction to End of Frame Timing"]
    pub mod fseof {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::FSEOF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FSEOFGR {
            bits: u8,
        }
        impl FSEOFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FSEOFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FSEOFGW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - Full-Speed End-of-Frame Gap"]
            #[inline]
            pub fn fseofg(&self) -> FSEOFGR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                FSEOFGR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - Full-Speed End-of-Frame Gap"]
            #[inline]
            pub fn fseofg(&mut self) -> _FSEOFGW {
                _FSEOFGW { w: self }
            }
        }
    }
    #[doc = "USB Low-Speed Last Transaction to End of Frame Timing"]
    pub struct LSEOF {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Low-Speed Last Transaction to End of Frame Timing"]
    pub mod lseof {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::LSEOF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct LSEOFGR {
            bits: u8,
        }
        impl LSEOFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _LSEOFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LSEOFGW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - Low-Speed End-of-Frame Gap"]
            #[inline]
            pub fn lseofg(&self) -> LSEOFGR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                LSEOFGR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - Low-Speed End-of-Frame Gap"]
            #[inline]
            pub fn lseofg(&mut self) -> _LSEOFGW {
                _LSEOFGW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 0"]
    pub struct TXFUNCADDR0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 0"]
    pub mod txfuncaddr0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 0"]
    pub struct TXHUBADDR0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 0"]
    pub mod txhubaddr0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 0"]
    pub struct TXHUBPORT0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 0"]
    pub mod txhubport0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 1"]
    pub struct TXFUNCADDR1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 1"]
    pub mod txfuncaddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 1"]
    pub struct TXHUBADDR1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 1"]
    pub mod txhubaddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 1"]
    pub struct TXHUBPORT1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 1"]
    pub mod txhubport1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 1"]
    pub struct RXFUNCADDR1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 1"]
    pub mod rxfuncaddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 1"]
    pub struct RXHUBADDR1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 1"]
    pub mod rxhubaddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 1"]
    pub struct RXHUBPORT1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 1"]
    pub mod rxhubport1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 2"]
    pub struct TXFUNCADDR2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 2"]
    pub mod txfuncaddr2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 2"]
    pub struct TXHUBADDR2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 2"]
    pub mod txhubaddr2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 2"]
    pub struct TXHUBPORT2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 2"]
    pub mod txhubport2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 2"]
    pub struct RXFUNCADDR2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 2"]
    pub mod rxfuncaddr2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 2"]
    pub struct RXHUBADDR2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 2"]
    pub mod rxhubaddr2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 2"]
    pub struct RXHUBPORT2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 2"]
    pub mod rxhubport2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 3"]
    pub struct TXFUNCADDR3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 3"]
    pub mod txfuncaddr3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 3"]
    pub struct TXHUBADDR3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 3"]
    pub mod txhubaddr3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 3"]
    pub struct TXHUBPORT3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 3"]
    pub mod txhubport3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 3"]
    pub struct RXFUNCADDR3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 3"]
    pub mod rxfuncaddr3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 3"]
    pub struct RXHUBADDR3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 3"]
    pub mod rxhubaddr3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 3"]
    pub struct RXHUBPORT3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 3"]
    pub mod rxhubport3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 4"]
    pub struct TXFUNCADDR4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 4"]
    pub mod txfuncaddr4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 4"]
    pub struct TXHUBADDR4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 4"]
    pub mod txhubaddr4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 4"]
    pub struct TXHUBPORT4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 4"]
    pub mod txhubport4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 4"]
    pub struct RXFUNCADDR4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 4"]
    pub mod rxfuncaddr4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 4"]
    pub struct RXHUBADDR4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 4"]
    pub mod rxhubaddr4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 4"]
    pub struct RXHUBPORT4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 4"]
    pub mod rxhubport4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 5"]
    pub struct TXFUNCADDR5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 5"]
    pub mod txfuncaddr5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 5"]
    pub struct TXHUBADDR5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 5"]
    pub mod txhubaddr5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 5"]
    pub struct TXHUBPORT5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 5"]
    pub mod txhubport5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 5"]
    pub struct RXFUNCADDR5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 5"]
    pub mod rxfuncaddr5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 5"]
    pub struct RXHUBADDR5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 5"]
    pub mod rxhubaddr5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 5"]
    pub struct RXHUBPORT5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 5"]
    pub mod rxhubport5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 6"]
    pub struct TXFUNCADDR6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 6"]
    pub mod txfuncaddr6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 6"]
    pub struct TXHUBADDR6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 6"]
    pub mod txhubaddr6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 6"]
    pub struct TXHUBPORT6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 6"]
    pub mod txhubport6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 6"]
    pub struct RXFUNCADDR6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 6"]
    pub mod rxfuncaddr6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 6"]
    pub struct RXHUBADDR6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 6"]
    pub mod rxhubaddr6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 6"]
    pub struct RXHUBPORT6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 6"]
    pub mod rxhubport6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Functional Address Endpoint 7"]
    pub struct TXFUNCADDR7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Functional Address Endpoint 7"]
    pub mod txfuncaddr7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXFUNCADDR7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Address Endpoint 7"]
    pub struct TXHUBADDR7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Address Endpoint 7"]
    pub mod txhubaddr7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBADDR7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Hub Port Endpoint 7"]
    pub struct TXHUBPORT7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Hub Port Endpoint 7"]
    pub mod txhubport7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXHUBPORT7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Functional Address Endpoint 7"]
    pub struct RXFUNCADDR7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Functional Address Endpoint 7"]
    pub mod rxfuncaddr7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXFUNCADDR7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Device Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Address Endpoint 7"]
    pub struct RXHUBADDR7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Address Endpoint 7"]
    pub mod rxhubaddr7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBADDR7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB Receive Hub Port Endpoint 7"]
    pub struct RXHUBPORT7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Hub Port Endpoint 7"]
    pub mod rxhubport7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXHUBPORT7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORTR {
            bits: u8,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                PORTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - Hub Port"]
            #[inline]
            pub fn port(&mut self) -> _PORTW {
                _PORTW { w: self }
            }
        }
    }
    #[doc = "USB Control and Status Endpoint 0 Low"]
    pub struct CSRL0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Control and Status Endpoint 0 Low"]
    pub mod csrl0 {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::CSRL0 {
            #[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 _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAENDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAENDW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETENDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETENDW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STATUSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STATUSW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYCW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETENDCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETENDCW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << 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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 2 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 3 - Data End"]
            #[inline]
            pub fn dataend(&mut self) -> _DATAENDW {
                _DATAENDW { w: self }
            }
            #[doc = "Bit 3 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 4 - Setup End"]
            #[inline]
            pub fn setend(&mut self) -> _SETENDW {
                _SETENDW { w: self }
            }
            #[doc = "Bit 4 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 5 - Send Stall"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 6 - STATUS Packet"]
            #[inline]
            pub fn status(&mut self) -> _STATUSW {
                _STATUSW { w: self }
            }
            #[doc = "Bit 6 - RXRDY Clear"]
            #[inline]
            pub fn rxrdyc(&mut self) -> _RXRDYCW {
                _RXRDYCW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 7 - Setup End Clear"]
            #[inline]
            pub fn setendc(&mut self) -> _SETENDCW {
                _SETENDCW { w: self }
            }
        }
    }
    #[doc = "USB Control and Status Endpoint 0 High"]
    pub struct CSRH0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Control and Status Endpoint 0 High"]
    pub mod csrh0 {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::CSRH0 {
            #[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 _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISPINGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISPINGW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << 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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - PING Disable"]
            #[inline]
            pub fn disping(&mut self) -> _DISPINGW {
                _DISPINGW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 0"]
    pub struct COUNT0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Byte Count Endpoint 0"]
    pub mod count0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::COUNT0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u8,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - FIFO Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Type Endpoint 0"]
    pub struct TYPE0 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Type Endpoint 0"]
    pub mod type0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TYPE0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                    SPEEDR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    i => SPEEDR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB NAK Limit"]
    pub struct NAKLMT {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB NAK Limit"]
    pub mod naklmt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::NAKLMT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKLMTR {
            bits: u8,
        }
        impl NAKLMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKLMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKLMTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:4 - EP0 NAK Limit"]
            #[inline]
            pub fn naklmt(&self) -> NAKLMTR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                NAKLMTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:4 - EP0 NAK Limit"]
            #[inline]
            pub fn naklmt(&mut self) -> _NAKLMTW {
                _NAKLMTW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 1"]
    pub struct TXMAXP1 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 1"]
    pub mod txmaxp1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 1 Low"]
    pub struct TXCSRL1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 1 Low"]
    pub mod txcsrl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 1 High"]
    pub struct TXCSRH1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 1 High"]
    pub mod txcsrh1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 1"]
    pub struct RXMAXP1 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 1"]
    pub mod rxmaxp1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 1 Low"]
    pub struct RXCSRL1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 1 Low"]
    pub mod rxcsrl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 1 High"]
    pub struct RXCSRH1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 1 High"]
    pub mod rxcsrh1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 1"]
    pub struct RXCOUNT1 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 1"]
    pub mod rxcount1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 1"]
    pub struct TXTYPE1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 1"]
    pub mod txtype1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 1"]
    pub struct TXINTERVAL1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 1"]
    pub mod txinterval1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 1"]
    pub struct RXTYPE1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 1"]
    pub mod rxtype1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 1"]
    pub struct RXINTERVAL1 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 1"]
    pub mod rxinterval1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 2"]
    pub struct TXMAXP2 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 2"]
    pub mod txmaxp2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 2 Low"]
    pub struct TXCSRL2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 2 Low"]
    pub mod txcsrl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 2 High"]
    pub struct TXCSRH2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 2 High"]
    pub mod txcsrh2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 2"]
    pub struct RXMAXP2 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 2"]
    pub mod rxmaxp2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 2 Low"]
    pub struct RXCSRL2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 2 Low"]
    pub mod rxcsrl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 2 High"]
    pub struct RXCSRH2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 2 High"]
    pub mod rxcsrh2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 2"]
    pub struct RXCOUNT2 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 2"]
    pub mod rxcount2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 2"]
    pub struct TXTYPE2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 2"]
    pub mod txtype2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 2"]
    pub struct TXINTERVAL2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 2"]
    pub mod txinterval2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 2"]
    pub struct RXTYPE2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 2"]
    pub mod rxtype2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 2"]
    pub struct RXINTERVAL2 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 2"]
    pub mod rxinterval2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 3"]
    pub struct TXMAXP3 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 3"]
    pub mod txmaxp3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 3 Low"]
    pub struct TXCSRL3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 3 Low"]
    pub mod txcsrl3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 3 High"]
    pub struct TXCSRH3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 3 High"]
    pub mod txcsrh3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 3"]
    pub struct RXMAXP3 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 3"]
    pub mod rxmaxp3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 3 Low"]
    pub struct RXCSRL3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 3 Low"]
    pub mod rxcsrl3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 3 High"]
    pub struct RXCSRH3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 3 High"]
    pub mod rxcsrh3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 3"]
    pub struct RXCOUNT3 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 3"]
    pub mod rxcount3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT3 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 3"]
    pub struct TXTYPE3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 3"]
    pub mod txtype3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 3"]
    pub struct TXINTERVAL3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 3"]
    pub mod txinterval3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 3"]
    pub struct RXTYPE3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 3"]
    pub mod rxtype3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 3"]
    pub struct RXINTERVAL3 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 3"]
    pub mod rxinterval3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 4"]
    pub struct TXMAXP4 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 4"]
    pub mod txmaxp4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 4 Low"]
    pub struct TXCSRL4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 4 Low"]
    pub mod txcsrl4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 4 High"]
    pub struct TXCSRH4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 4 High"]
    pub mod txcsrh4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 4"]
    pub struct RXMAXP4 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 4"]
    pub mod rxmaxp4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 4 Low"]
    pub struct RXCSRL4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 4 Low"]
    pub mod rxcsrl4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 4 High"]
    pub struct RXCSRH4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 4 High"]
    pub mod rxcsrh4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 4"]
    pub struct RXCOUNT4 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 4"]
    pub mod rxcount4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT4 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 4"]
    pub struct TXTYPE4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 4"]
    pub mod txtype4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 4"]
    pub struct TXINTERVAL4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 4"]
    pub mod txinterval4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 4"]
    pub struct RXTYPE4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 4"]
    pub mod rxtype4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 4"]
    pub struct RXINTERVAL4 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 4"]
    pub mod rxinterval4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 5"]
    pub struct TXMAXP5 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 5"]
    pub mod txmaxp5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 5 Low"]
    pub struct TXCSRL5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 5 Low"]
    pub mod txcsrl5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 5 High"]
    pub struct TXCSRH5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 5 High"]
    pub mod txcsrh5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 5"]
    pub struct RXMAXP5 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 5"]
    pub mod rxmaxp5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 5 Low"]
    pub struct RXCSRL5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 5 Low"]
    pub mod rxcsrl5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 5 High"]
    pub struct RXCSRH5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 5 High"]
    pub mod rxcsrh5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 5"]
    pub struct RXCOUNT5 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 5"]
    pub mod rxcount5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT5 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 5"]
    pub struct TXTYPE5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 5"]
    pub mod txtype5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 5"]
    pub struct TXINTERVAL5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 5"]
    pub mod txinterval5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 5"]
    pub struct RXTYPE5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 5"]
    pub mod rxtype5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 5"]
    pub struct RXINTERVAL5 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 5"]
    pub mod rxinterval5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 6"]
    pub struct TXMAXP6 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 6"]
    pub mod txmaxp6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 6 Low"]
    pub struct TXCSRL6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 6 Low"]
    pub mod txcsrl6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 6 High"]
    pub struct TXCSRH6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 6 High"]
    pub mod txcsrh6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 6"]
    pub struct RXMAXP6 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 6"]
    pub mod rxmaxp6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 6 Low"]
    pub struct RXCSRL6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 6 Low"]
    pub mod rxcsrl6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 6 High"]
    pub struct RXCSRH6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 6 High"]
    pub mod rxcsrh6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 6"]
    pub struct RXCOUNT6 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 6"]
    pub mod rxcount6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT6 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 6"]
    pub struct TXTYPE6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 6"]
    pub mod txtype6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 6"]
    pub struct TXINTERVAL6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 6"]
    pub mod txinterval6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 6"]
    pub struct RXTYPE6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 6"]
    pub mod rxtype6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 6"]
    pub struct RXINTERVAL6 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 6"]
    pub mod rxinterval6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Transmit Data Endpoint 7"]
    pub struct TXMAXP7 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Transmit Data Endpoint 7"]
    pub mod txmaxp7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXMAXP7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 7 Low"]
    pub struct TXCSRL7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 7 Low"]
    pub mod txcsrl7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXRDYR {
            bits: bool,
        }
        impl TXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FIFONER {
            bits: bool,
        }
        impl FIFONER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNDRNR {
            bits: bool,
        }
        impl UNDRNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETUPR {
            bits: bool,
        }
        impl SETUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FIFONEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FIFONEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNDRNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNDRNW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETUPW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&self) -> TXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&self) -> FIFONER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FIFONER { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&self) -> UNDRNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                UNDRNR { bits }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&self) -> SETUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                SETUPR { bits }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Transmit Packet Ready"]
            #[inline]
            pub fn txrdy(&mut self) -> _TXRDYW {
                _TXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Not Empty"]
            #[inline]
            pub fn fifone(&mut self) -> _FIFONEW {
                _FIFONEW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Underrun"]
            #[inline]
            pub fn undrn(&mut self) -> _UNDRNW {
                _UNDRNW { w: self }
            }
            #[doc = "Bit 3 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 4 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 4 - Setup Packet"]
            #[inline]
            pub fn setup(&mut self) -> _SETUPW {
                _SETUPW { w: self }
            }
            #[doc = "Bit 5 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 6 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
            #[doc = "Bit 7 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
        }
    }
    #[doc = "USB Transmit Control and Status Endpoint 7 High"]
    pub struct TXCSRH7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Transmit Control and Status Endpoint 7 High"]
    pub mod txcsrh7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXCSRH7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FDTR {
            bits: bool,
        }
        impl FDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOSETR {
            bits: bool,
        }
        impl AUTOSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FDTW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOSETW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&self) -> FDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FDTR { bits }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&self) -> AUTOSETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOSETR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 2 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 3 - Force Data Toggle"]
            #[inline]
            pub fn fdt(&mut self) -> _FDTW {
                _FDTW { w: self }
            }
            #[doc = "Bit 4 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 5 - Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 7 - Auto Set"]
            #[inline]
            pub fn autoset(&mut self) -> _AUTOSETW {
                _AUTOSETW { w: self }
            }
        }
    }
    #[doc = "USB Maximum Receive Data Endpoint 7"]
    pub struct RXMAXP7 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Maximum Receive Data Endpoint 7"]
    pub mod rxmaxp7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXMAXP7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXLOADR {
            bits: u16,
        }
        impl MAXLOADR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXLOADW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXLOADW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&self) -> MAXLOADR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                MAXLOADR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:10 - Maximum Payload"]
            #[inline]
            pub fn maxload(&mut self) -> _MAXLOADW {
                _MAXLOADW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 7 Low"]
    pub struct RXCSRL7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 7 Low"]
    pub mod rxcsrl7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXRDYR {
            bits: bool,
        }
        impl RXRDYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FULLR {
            bits: bool,
        }
        impl FULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRORR {
            bits: bool,
        }
        impl ERRORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVERR {
            bits: bool,
        }
        impl OVERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAERRR {
            bits: bool,
        }
        impl DATAERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKTOR {
            bits: bool,
        }
        impl NAKTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FLUSHR {
            bits: bool,
        }
        impl FLUSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct REQPKTR {
            bits: bool,
        }
        impl REQPKTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLEDR {
            bits: bool,
        }
        impl STALLEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRDTR {
            bits: bool,
        }
        impl CLRDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXRDYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXRDYW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FULLW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRORW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVERW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAERRW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NAKTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NAKTOW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLUSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLUSHW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REQPKTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REQPKTW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STALLEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STALLEDW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRDTW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&self) -> RXRDYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RXRDYR { bits }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&self) -> FULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FULLR { bits }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&self) -> ERRORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRORR { bits }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&self) -> OVERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                OVERR { bits }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&self) -> DATAERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DATAERRR { bits }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&self) -> NAKTOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKTOR { bits }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&self) -> FLUSHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                FLUSHR { bits }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&self) -> REQPKTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                REQPKTR { bits }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&self) -> STALLEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLEDR { bits }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&self) -> CLRDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CLRDTR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Receive Packet Ready"]
            #[inline]
            pub fn rxrdy(&mut self) -> _RXRDYW {
                _RXRDYW { w: self }
            }
            #[doc = "Bit 1 - FIFO Full"]
            #[inline]
            pub fn full(&mut self) -> _FULLW {
                _FULLW { w: self }
            }
            #[doc = "Bit 2 - Error"]
            #[inline]
            pub fn error(&mut self) -> _ERRORW {
                _ERRORW { w: self }
            }
            #[doc = "Bit 2 - Overrun"]
            #[inline]
            pub fn over(&mut self) -> _OVERW {
                _OVERW { w: self }
            }
            #[doc = "Bit 3 - Data Error"]
            #[inline]
            pub fn dataerr(&mut self) -> _DATAERRW {
                _DATAERRW { w: self }
            }
            #[doc = "Bit 3 - NAK Timeout"]
            #[inline]
            pub fn nakto(&mut self) -> _NAKTOW {
                _NAKTOW { w: self }
            }
            #[doc = "Bit 4 - Flush FIFO"]
            #[inline]
            pub fn flush(&mut self) -> _FLUSHW {
                _FLUSHW { w: self }
            }
            #[doc = "Bit 5 - Request Packet"]
            #[inline]
            pub fn reqpkt(&mut self) -> _REQPKTW {
                _REQPKTW { w: self }
            }
            #[doc = "Bit 5 - Send STALL"]
            #[inline]
            pub fn stall(&mut self) -> _STALLW {
                _STALLW { w: self }
            }
            #[doc = "Bit 6 - Endpoint Stalled"]
            #[inline]
            pub fn stalled(&mut self) -> _STALLEDW {
                _STALLEDW { w: self }
            }
            #[doc = "Bit 7 - Clear Data Toggle"]
            #[inline]
            pub fn clrdt(&mut self) -> _CLRDTW {
                _CLRDTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Control and Status Endpoint 7 High"]
    pub struct RXCSRH7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Receive Control and Status Endpoint 7 High"]
    pub mod rxcsrh7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXCSRH7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INCOMPRXR {
            bits: bool,
        }
        impl INCOMPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTWER {
            bits: bool,
        }
        impl DTWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMODR {
            bits: bool,
        }
        impl DMAMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIDERRR {
            bits: bool,
        }
        impl PIDERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISNYETR {
            bits: bool,
        }
        impl DISNYETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: bool,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOR {
            bits: bool,
        }
        impl ISOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTORQR {
            bits: bool,
        }
        impl AUTORQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AUTOCLR {
            bits: bool,
        }
        impl AUTOCLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INCOMPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INCOMPRXW<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTWEW<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAMODW<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIDERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIDERRW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISNYETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISNYETW<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTORQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTORQW<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AUTOCLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AUTOCLW<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&self) -> INCOMPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                INCOMPRXR { bits }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTR { bits }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&self) -> DTWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DTWER { bits }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&self) -> DMAMODR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAMODR { bits }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&self) -> PIDERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                PIDERRR { bits }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&self) -> DISNYETR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DISNYETR { bits }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                DMAENR { bits }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&self) -> ISOR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ISOR { bits }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&self) -> AUTORQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTORQR { bits }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&self) -> AUTOCLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                AUTOCLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Incomplete RX Transmission Status"]
            #[inline]
            pub fn incomprx(&mut self) -> _INCOMPRXW {
                _INCOMPRXW { w: self }
            }
            #[doc = "Bit 1 - Data Toggle"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
            #[doc = "Bit 2 - Data Toggle Write Enable"]
            #[inline]
            pub fn dtwe(&mut self) -> _DTWEW {
                _DTWEW { w: self }
            }
            #[doc = "Bit 3 - DMA Request Mode"]
            #[inline]
            pub fn dmamod(&mut self) -> _DMAMODW {
                _DMAMODW { w: self }
            }
            #[doc = "Bit 4 - PID Error"]
            #[inline]
            pub fn piderr(&mut self) -> _PIDERRW {
                _PIDERRW { w: self }
            }
            #[doc = "Bit 4 - Disable NYET"]
            #[inline]
            pub fn disnyet(&mut self) -> _DISNYETW {
                _DISNYETW { w: self }
            }
            #[doc = "Bit 5 - DMA Request Enable"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
            #[doc = "Bit 6 - Isochronous Transfers"]
            #[inline]
            pub fn iso(&mut self) -> _ISOW {
                _ISOW { w: self }
            }
            #[doc = "Bit 6 - Auto Request"]
            #[inline]
            pub fn autorq(&mut self) -> _AUTORQW {
                _AUTORQW { w: self }
            }
            #[doc = "Bit 7 - Auto Clear"]
            #[inline]
            pub fn autocl(&mut self) -> _AUTOCLW {
                _AUTOCLW { w: self }
            }
        }
    }
    #[doc = "USB Receive Byte Count Endpoint 7"]
    pub struct RXCOUNT7 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Byte Count Endpoint 7"]
    pub mod rxcount7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::RXCOUNT7 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:12 - Receive Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 7"]
    pub struct TXTYPE7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Configure Type Endpoint 7"]
    pub mod txtype7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXTYPE7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Transmit Interval Endpoint 7"]
    pub struct TXINTERVAL7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Transmit Interval Endpoint 7"]
    pub mod txinterval7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::TXINTERVAL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - TX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB Host Configure Receive Type Endpoint 7"]
    pub struct RXTYPE7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Configure Receive Type Endpoint 7"]
    pub mod rxtype7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXTYPE7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TEPR {
            bits: u8,
        }
        impl TEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PROTO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTOR {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTOR::CTRL => 0,
                    PROTOR::ISOC => 0x01,
                    PROTOR::BULK => 0x02,
                    PROTOR::INT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTOR {
                match value {
                    0 => PROTOR::CTRL,
                    1 => PROTOR::ISOC,
                    2 => PROTOR::BULK,
                    3 => PROTOR::INT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `CTRL`"]
            #[inline]
            pub fn is_ctrl(&self) -> bool {
                *self == PROTOR::CTRL
            }
            #[doc = "Checks if the value of the field is `ISOC`"]
            #[inline]
            pub fn is_isoc(&self) -> bool {
                *self == PROTOR::ISOC
            }
            #[doc = "Checks if the value of the field is `BULK`"]
            #[inline]
            pub fn is_bulk(&self) -> bool {
                *self == PROTOR::BULK
            }
            #[doc = "Checks if the value of the field is `INT`"]
            #[inline]
            pub fn is_int(&self) -> bool {
                *self == PROTOR::INT
            }
        }
        #[doc = "Possible values of the field `SPEED`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SPEEDR {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SPEEDR::DFLT => 0,
                    SPEEDR::HIGH => 0x01,
                    SPEEDR::FULL => 0x02,
                    SPEEDR::LOW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SPEEDR {
                match value {
                    0 => SPEEDR::DFLT,
                    1 => SPEEDR::HIGH,
                    2 => SPEEDR::FULL,
                    3 => SPEEDR::LOW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `DFLT`"]
            #[inline]
            pub fn is_dflt(&self) -> bool {
                *self == SPEEDR::DFLT
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == SPEEDR::HIGH
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == SPEEDR::FULL
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == SPEEDR::LOW
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PROTO`"]
        pub enum PROTOW {
            #[doc = "Control"]
            CTRL,
            #[doc = "Isochronous"]
            ISOC,
            #[doc = "Bulk"]
            BULK,
            #[doc = "Interrupt"]
            INT,
        }
        impl PROTOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTOW::CTRL => 0,
                    PROTOW::ISOC => 1,
                    PROTOW::BULK => 2,
                    PROTOW::INT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTOW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Control"]
            #[inline]
            pub fn ctrl(self) -> &'a mut W {
                self.variant(PROTOW::CTRL)
            }
            #[doc = "Isochronous"]
            #[inline]
            pub fn isoc(self) -> &'a mut W {
                self.variant(PROTOW::ISOC)
            }
            #[doc = "Bulk"]
            #[inline]
            pub fn bulk(self) -> &'a mut W {
                self.variant(PROTOW::BULK)
            }
            #[doc = "Interrupt"]
            #[inline]
            pub fn int(self) -> &'a mut W {
                self.variant(PROTOW::INT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SPEED`"]
        pub enum SPEEDW {
            #[doc = "Default"]
            DFLT,
            #[doc = "High"]
            HIGH,
            #[doc = "Full"]
            FULL,
            #[doc = "Low"]
            LOW,
        }
        impl SPEEDW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SPEEDW::DFLT => 0,
                    SPEEDW::HIGH => 1,
                    SPEEDW::FULL => 2,
                    SPEEDW::LOW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPEEDW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SPEEDW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Default"]
            #[inline]
            pub fn dflt(self) -> &'a mut W {
                self.variant(SPEEDW::DFLT)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(SPEEDW::HIGH)
            }
            #[doc = "Full"]
            #[inline]
            pub fn full(self) -> &'a mut W {
                self.variant(SPEEDW::FULL)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(SPEEDW::LOW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&self) -> TEPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TEPR { bits }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&self) -> PROTOR {
                PROTOR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&self) -> SPEEDR {
                SPEEDR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - Target Endpoint Number"]
            #[inline]
            pub fn tep(&mut self) -> _TEPW {
                _TEPW { w: self }
            }
            #[doc = "Bits 4:5 - Protocol"]
            #[inline]
            pub fn proto(&mut self) -> _PROTOW {
                _PROTOW { w: self }
            }
            #[doc = "Bits 6:7 - Operating Speed"]
            #[inline]
            pub fn speed(&mut self) -> _SPEEDW {
                _SPEEDW { w: self }
            }
        }
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 7"]
    pub struct RXINTERVAL7 {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB Host Receive Polling Interval Endpoint 7"]
    pub mod rxinterval7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::RXINTERVAL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPOLLR {
            bits: u8,
        }
        impl TXPOLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPOLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPOLLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&self) -> TXPOLLR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                TXPOLLR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:7 - RX Polling"]
            #[inline]
            pub fn txpoll(&mut self) -> _TXPOLLW {
                _TXPOLLW { w: self }
            }
        }
    }
    #[doc = "USB DMA Interrupt"]
    pub struct DMAINTR {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB DMA Interrupt"]
    pub mod dmaintr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::DMAINTR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH0R {
            bits: bool,
        }
        impl CH0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH1R {
            bits: bool,
        }
        impl CH1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH2R {
            bits: bool,
        }
        impl CH2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH3R {
            bits: bool,
        }
        impl CH3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH4R {
            bits: bool,
        }
        impl CH4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH5R {
            bits: bool,
        }
        impl CH5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH6R {
            bits: bool,
        }
        impl CH6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH7R {
            bits: bool,
        }
        impl CH7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH0W<'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 u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH1W<'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 = 1;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH2W<'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 = 2;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH3W<'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 = 3;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH4W<'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 = 4;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH5W<'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 = 5;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH6W<'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 = 6;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH7W<'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 = 7;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Channel 0 DMA Interrupt"]
            #[inline]
            pub fn ch0(&self) -> CH0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH0R { bits }
            }
            #[doc = "Bit 1 - Channel 1 DMA Interrupt"]
            #[inline]
            pub fn ch1(&self) -> CH1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH1R { bits }
            }
            #[doc = "Bit 2 - Channel 2 DMA Interrupt"]
            #[inline]
            pub fn ch2(&self) -> CH2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH2R { bits }
            }
            #[doc = "Bit 3 - Channel 3 DMA Interrupt"]
            #[inline]
            pub fn ch3(&self) -> CH3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH3R { bits }
            }
            #[doc = "Bit 4 - Channel 4 DMA Interrupt"]
            #[inline]
            pub fn ch4(&self) -> CH4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH4R { bits }
            }
            #[doc = "Bit 5 - Channel 5 DMA Interrupt"]
            #[inline]
            pub fn ch5(&self) -> CH5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH5R { bits }
            }
            #[doc = "Bit 6 - Channel 6 DMA Interrupt"]
            #[inline]
            pub fn ch6(&self) -> CH6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH6R { bits }
            }
            #[doc = "Bit 7 - Channel 7 DMA Interrupt"]
            #[inline]
            pub fn ch7(&self) -> CH7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                CH7R { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - Channel 0 DMA Interrupt"]
            #[inline]
            pub fn ch0(&mut self) -> _CH0W {
                _CH0W { w: self }
            }
            #[doc = "Bit 1 - Channel 1 DMA Interrupt"]
            #[inline]
            pub fn ch1(&mut self) -> _CH1W {
                _CH1W { w: self }
            }
            #[doc = "Bit 2 - Channel 2 DMA Interrupt"]
            #[inline]
            pub fn ch2(&mut self) -> _CH2W {
                _CH2W { w: self }
            }
            #[doc = "Bit 3 - Channel 3 DMA Interrupt"]
            #[inline]
            pub fn ch3(&mut self) -> _CH3W {
                _CH3W { w: self }
            }
            #[doc = "Bit 4 - Channel 4 DMA Interrupt"]
            #[inline]
            pub fn ch4(&mut self) -> _CH4W {
                _CH4W { w: self }
            }
            #[doc = "Bit 5 - Channel 5 DMA Interrupt"]
            #[inline]
            pub fn ch5(&mut self) -> _CH5W {
                _CH5W { w: self }
            }
            #[doc = "Bit 6 - Channel 6 DMA Interrupt"]
            #[inline]
            pub fn ch6(&mut self) -> _CH6W {
                _CH6W { w: self }
            }
            #[doc = "Bit 7 - Channel 7 DMA Interrupt"]
            #[inline]
            pub fn ch7(&mut self) -> _CH7W {
                _CH7W { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 0"]
    pub struct DMACTL0 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 0"]
    pub mod dmactl0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 0"]
    pub struct DMAADDR0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 0"]
    pub mod dmaaddr0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 0"]
    pub struct DMACOUNT0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 0"]
    pub mod dmacount0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 1"]
    pub struct DMACTL1 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 1"]
    pub mod dmactl1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 1"]
    pub struct DMAADDR1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 1"]
    pub mod dmaaddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 1"]
    pub struct DMACOUNT1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 1"]
    pub mod dmacount1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 2"]
    pub struct DMACTL2 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 2"]
    pub mod dmactl2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 2"]
    pub struct DMAADDR2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 2"]
    pub mod dmaaddr2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 2"]
    pub struct DMACOUNT2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 2"]
    pub mod dmacount2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 3"]
    pub struct DMACTL3 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 3"]
    pub mod dmactl3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 3"]
    pub struct DMAADDR3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 3"]
    pub mod dmaaddr3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 3"]
    pub struct DMACOUNT3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 3"]
    pub mod dmacount3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 4"]
    pub struct DMACTL4 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 4"]
    pub mod dmactl4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 4"]
    pub struct DMAADDR4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 4"]
    pub mod dmaaddr4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 4"]
    pub struct DMACOUNT4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 4"]
    pub mod dmacount4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 5"]
    pub struct DMACTL5 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 5"]
    pub mod dmactl5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 5"]
    pub struct DMAADDR5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 5"]
    pub mod dmaaddr5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 5"]
    pub struct DMACOUNT5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 5"]
    pub mod dmacount5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 6"]
    pub struct DMACTL6 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 6"]
    pub mod dmactl6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 6"]
    pub struct DMAADDR6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 6"]
    pub mod dmaaddr6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 6"]
    pub struct DMACOUNT6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 6"]
    pub mod dmacount6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB DMA Control 7"]
    pub struct DMACTL7 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB DMA Control 7"]
    pub mod dmactl7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::DMACTL7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENABLER {
            bits: bool,
        }
        impl ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: bool,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MODER {
            bits: bool,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IER {
            bits: bool,
        }
        impl IER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPR {
            bits: u8,
        }
        impl EPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BRSTM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BRSTMR {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BRSTMR::ANY => 0,
                    BRSTMR::INC4 => 0x01,
                    BRSTMR::INC8 => 0x02,
                    BRSTMR::INC16 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BRSTMR {
                match value {
                    0 => BRSTMR::ANY,
                    1 => BRSTMR::INC4,
                    2 => BRSTMR::INC8,
                    3 => BRSTMR::INC16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ANY`"]
            #[inline]
            pub fn is_any(&self) -> bool {
                *self == BRSTMR::ANY
            }
            #[doc = "Checks if the value of the field is `INC4`"]
            #[inline]
            pub fn is_inc4(&self) -> bool {
                *self == BRSTMR::INC4
            }
            #[doc = "Checks if the value of the field is `INC8`"]
            #[inline]
            pub fn is_inc8(&self) -> bool {
                *self == BRSTMR::INC8
            }
            #[doc = "Checks if the value of the field is `INC16`"]
            #[inline]
            pub fn is_inc16(&self) -> bool {
                *self == BRSTMR::INC16
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENABLEW<'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 u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IEW<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRW<'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 = 8;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BRSTM`"]
        pub enum BRSTMW {
            #[doc = "Bursts of unspecified length"]
            ANY,
            #[doc = "INCR4 or unspecified length"]
            INC4,
            #[doc = "INCR8, INCR4 or unspecified length"]
            INC8,
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            INC16,
        }
        impl BRSTMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BRSTMW::ANY => 0,
                    BRSTMW::INC4 => 1,
                    BRSTMW::INC8 => 2,
                    BRSTMW::INC16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRSTMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRSTMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BRSTMW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Bursts of unspecified length"]
            #[inline]
            pub fn any(self) -> &'a mut W {
                self.variant(BRSTMW::ANY)
            }
            #[doc = "INCR4 or unspecified length"]
            #[inline]
            pub fn inc4(self) -> &'a mut W {
                self.variant(BRSTMW::INC4)
            }
            #[doc = "INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc8(self) -> &'a mut W {
                self.variant(BRSTMW::INC8)
            }
            #[doc = "INCR16, INCR8, INCR4 or unspecified length"]
            #[inline]
            pub fn inc16(self) -> &'a mut W {
                self.variant(BRSTMW::INC16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 9;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&self) -> ENABLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ENABLER { bits }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                DIRR { bits }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                MODER { bits }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&self) -> IER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                IER { bits }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&self) -> EPR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                EPR { bits }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                ERRR { bits }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&self) -> BRSTMR {
                BRSTMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 0 - DMA Transfer Enable"]
            #[inline]
            pub fn enable(&mut self) -> _ENABLEW {
                _ENABLEW { w: self }
            }
            #[doc = "Bit 1 - DMA Direction"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
            #[doc = "Bit 2 - DMA Transfer Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 3 - DMA Interrupt Enable"]
            #[inline]
            pub fn ie(&mut self) -> _IEW {
                _IEW { w: self }
            }
            #[doc = "Bits 4:7 - Endpoint number"]
            #[inline]
            pub fn ep(&mut self) -> _EPW {
                _EPW { w: self }
            }
            #[doc = "Bit 8 - Bus Error Bit"]
            #[inline]
            pub fn err(&mut self) -> _ERRW {
                _ERRW { w: self }
            }
            #[doc = "Bits 9:10 - Burst Mode"]
            #[inline]
            pub fn brstm(&mut self) -> _BRSTMW {
                _BRSTMW { w: self }
            }
        }
    }
    #[doc = "USB DMA Address 7"]
    pub struct DMAADDR7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Address 7"]
    pub mod dmaaddr7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAADDR7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 2:31 - DMA Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB DMA Count 7"]
    pub struct DMACOUNT7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB DMA Count 7"]
    pub mod dmacount7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACOUNT7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u32,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - DMA Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                COUNTR { bits }
            }
        }
        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 2:31 - DMA Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 1"]
    pub struct RQPKTCOUNT1 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 1"]
    pub mod rqpktcount1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 2"]
    pub struct RQPKTCOUNT2 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 2"]
    pub mod rqpktcount2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 3"]
    pub struct RQPKTCOUNT3 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 3"]
    pub mod rqpktcount3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 4"]
    pub struct RQPKTCOUNT4 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 4"]
    pub mod rqpktcount4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 5"]
    pub struct RQPKTCOUNT5 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 5"]
    pub mod rqpktcount5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 6"]
    pub struct RQPKTCOUNT6 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 6"]
    pub mod rqpktcount6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 7"]
    pub struct RQPKTCOUNT7 {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Request Packet Count in Block Transfer Endpoint 7"]
    pub mod rqpktcount7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RQPKTCOUNT7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u16,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                COUNTR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - Block Transfer Packet Count"]
            #[inline]
            pub fn count(&mut self) -> _COUNTW {
                _COUNTW { w: self }
            }
        }
    }
    #[doc = "USB Receive Double Packet Buffer Disable"]
    pub struct RXDPKTBUFDIS {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Receive Double Packet Buffer Disable"]
    pub mod rxdpktbufdis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::RXDPKTBUFDIS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP1W<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP2W<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP3W<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP4W<'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 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP5W<'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 = 5;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP6W<'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 = 6;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP7W<'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 = 7;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 1 - EP1 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - EP2 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - EP3 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - EP4 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - EP5 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - EP6 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - EP7 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 1 - EP1 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep1(&mut self) -> _EP1W {
                _EP1W { w: self }
            }
            #[doc = "Bit 2 - EP2 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep2(&mut self) -> _EP2W {
                _EP2W { w: self }
            }
            #[doc = "Bit 3 - EP3 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep3(&mut self) -> _EP3W {
                _EP3W { w: self }
            }
            #[doc = "Bit 4 - EP4 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep4(&mut self) -> _EP4W {
                _EP4W { w: self }
            }
            #[doc = "Bit 5 - EP5 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep5(&mut self) -> _EP5W {
                _EP5W { w: self }
            }
            #[doc = "Bit 6 - EP6 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep6(&mut self) -> _EP6W {
                _EP6W { w: self }
            }
            #[doc = "Bit 7 - EP7 RX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep7(&mut self) -> _EP7W {
                _EP7W { w: self }
            }
        }
    }
    #[doc = "USB Transmit Double Packet Buffer Disable"]
    pub struct TXDPKTBUFDIS {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Transmit Double Packet Buffer Disable"]
    pub mod txdpktbufdis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::TXDPKTBUFDIS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP1R {
            bits: bool,
        }
        impl EP1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP2R {
            bits: bool,
        }
        impl EP2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP3R {
            bits: bool,
        }
        impl EP3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP4R {
            bits: bool,
        }
        impl EP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP5R {
            bits: bool,
        }
        impl EP5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP6R {
            bits: bool,
        }
        impl EP6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EP7R {
            bits: bool,
        }
        impl EP7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP1W<'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 = 1;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP2W<'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 = 2;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP3W<'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 = 3;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP4W<'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 = 4;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP5W<'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 = 5;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP6W<'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 = 6;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EP7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EP7W<'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 = 7;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bit 1 - EP1 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep1(&self) -> EP1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP1R { bits }
            }
            #[doc = "Bit 2 - EP2 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep2(&self) -> EP2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP2R { bits }
            }
            #[doc = "Bit 3 - EP3 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep3(&self) -> EP3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP3R { bits }
            }
            #[doc = "Bit 4 - EP4 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep4(&self) -> EP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP4R { bits }
            }
            #[doc = "Bit 5 - EP5 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep5(&self) -> EP5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP5R { bits }
            }
            #[doc = "Bit 6 - EP6 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep6(&self) -> EP6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP6R { bits }
            }
            #[doc = "Bit 7 - EP7 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep7(&self) -> EP7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                EP7R { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bit 1 - EP1 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep1(&mut self) -> _EP1W {
                _EP1W { w: self }
            }
            #[doc = "Bit 2 - EP2 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep2(&mut self) -> _EP2W {
                _EP2W { w: self }
            }
            #[doc = "Bit 3 - EP3 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep3(&mut self) -> _EP3W {
                _EP3W { w: self }
            }
            #[doc = "Bit 4 - EP4 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep4(&mut self) -> _EP4W {
                _EP4W { w: self }
            }
            #[doc = "Bit 5 - EP5 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep5(&mut self) -> _EP5W {
                _EP5W { w: self }
            }
            #[doc = "Bit 6 - EP6 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep6(&mut self) -> _EP6W {
                _EP6W { w: self }
            }
            #[doc = "Bit 7 - EP7 TX Double-Packet Buffer Disable"]
            #[inline]
            pub fn ep7(&mut self) -> _EP7W {
                _EP7W { w: self }
            }
        }
    }
    #[doc = "USB Chirp Timeout"]
    pub struct CTO {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB Chirp Timeout"]
    pub mod cto {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::CTO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CCTVR {
            bits: u16,
        }
        impl CCTVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CCTVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CCTVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - Configurable Chirp Timeout Value"]
            #[inline]
            pub fn cctv(&self) -> CCTVR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                CCTVR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - Configurable Chirp Timeout Value"]
            #[inline]
            pub fn cctv(&mut self) -> _CCTVW {
                _CCTVW { w: self }
            }
        }
    }
    #[doc = "USB High Speed to UTM Operating Delay"]
    pub struct HHSRTN {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB High Speed to UTM Operating Delay"]
    pub mod hhsrtn {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::HHSRTN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HHSRTNR {
            bits: u16,
        }
        impl HHSRTNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HHSRTNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HHSRTNW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:15 - HIgh Speed to UTM Operating Delay"]
            #[inline]
            pub fn hhsrtn(&self) -> HHSRTNR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u16
                };
                HHSRTNR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:15 - HIgh Speed to UTM Operating Delay"]
            #[inline]
            pub fn hhsrtn(&mut self) -> _HHSRTNW {
                _HHSRTNW { w: self }
            }
        }
    }
    #[doc = "USB High Speed Time-out Adder"]
    pub struct HSBT {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB High Speed Time-out Adder"]
    pub mod hsbt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u16,
        }
        impl super::HSBT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSBTR {
            bits: u8,
        }
        impl HSBTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSBTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSBTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u16) << OFFSET);
                self.w.bits |= ((value & MASK) as u16) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:3 - High Speed Timeout Adder"]
            #[inline]
            pub fn hsbt(&self) -> HSBTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                HSBTR { bits }
            }
        }
        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: u16) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:3 - High Speed Timeout Adder"]
            #[inline]
            pub fn hsbt(&mut self) -> _HSBTW {
                _HSBTW { w: self }
            }
        }
    }
    #[doc = "USB LPM Attributes"]
    pub struct LPMATTR {
        register: ::vcell::VolatileCell<u16>,
    }
    #[doc = "USB LPM Attributes"]
    pub mod lpmattr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u16,
        }
        impl super::LPMATTR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `LS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum LSR {
            #[doc = "Sleep State (L1)"]
            L1,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl LSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    LSR::L1 => 0x01,
                    LSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> LSR {
                match value {
                    1 => LSR::L1,
                    i => LSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `L1`"]
            #[inline]
            pub fn is_l1(&self) -> bool {
                *self == LSR::L1
            }
        }
        #[doc = r" Value of the field"]
        pub struct HIRDR {
            bits: u8,
        }
        impl HIRDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RMTWAKR {
            bits: bool,
        }
        impl RMTWAKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENDPTR {
            bits: u8,
        }
        impl ENDPTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
            #[doc = "Bits 0:3 - Link State"]
            #[inline]
            pub fn ls(&self) -> LSR {
                LSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                })
            }
            #[doc = "Bits 4:7 - Host Initiated Resume Duration"]
            #[inline]
            pub fn hird(&self) -> HIRDR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                HIRDR { bits }
            }
            #[doc = "Bit 8 - Remote Wake"]
            #[inline]
            pub fn rmtwak(&self) -> RMTWAKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u16) != 0
                };
                RMTWAKR { bits }
            }
            #[doc = "Bits 12:15 - Endpoint"]
            #[inline]
            pub fn endpt(&self) -> ENDPTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u16) as u8
                };
                ENDPTR { bits }
            }
        }
    }
    #[doc = "USB LPM Control"]
    pub struct LPMCNTRL {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB LPM Control"]
    pub mod lpmcntrl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::LPMCNTRL {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXLPMR {
            bits: bool,
        }
        impl TXLPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESR {
            bits: bool,
        }
        impl RESR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENR {
            #[doc = "LPM and Extended transactions are not supported. In this case, the USB does not respond to LPM transactions and LPM transactions cause a timeout"]
            NONE,
            #[doc = "LPM is not supported but extended transactions are supported. In this case, the USB does respond to an LPM transaction with a STALL"]
            EXT,
            #[doc = "The USB supports LPM extended transactions. In this case, the USB responds with a NYET or an ACK as determined by the value of TXLPM and other conditions"]
            LPMEXT,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENR::NONE => 0,
                    ENR::EXT => 0x01,
                    ENR::LPMEXT => 0x03,
                    ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENR {
                match value {
                    0 => ENR::NONE,
                    1 => ENR::EXT,
                    3 => ENR::LPMEXT,
                    i => ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ENR::NONE
            }
            #[doc = "Checks if the value of the field is `EXT`"]
            #[inline]
            pub fn is_ext(&self) -> bool {
                *self == ENR::EXT
            }
            #[doc = "Checks if the value of the field is `LPMEXT`"]
            #[inline]
            pub fn is_lpmext(&self) -> bool {
                *self == ENR::LPMEXT
            }
        }
        #[doc = r" Value of the field"]
        pub struct NAKR {
            bits: bool,
        }
        impl NAKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit LPM Transaction Enable"]
            #[inline]
            pub fn txlpm(&self) -> TXLPMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                TXLPMR { bits }
            }
            #[doc = "Bit 1 - LPM Resume"]
            #[inline]
            pub fn res(&self) -> RESR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESR { bits }
            }
            #[doc = "Bits 2:3 - LPM Enable"]
            #[inline]
            pub fn en(&self) -> ENR {
                ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                })
            }
            #[doc = "Bit 4 - LPM NAK"]
            #[inline]
            pub fn nak(&self) -> NAKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NAKR { bits }
            }
        }
    }
    #[doc = "USB LPM Interrupt Mask"]
    pub struct LPMIM {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB LPM Interrupt Mask"]
    pub mod lpmim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::LPMIM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct STALLR {
            bits: bool,
        }
        impl STALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NYR {
            bits: bool,
        }
        impl NYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACKR {
            bits: bool,
        }
        impl ACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NCR {
            bits: bool,
        }
        impl NCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESR {
            bits: bool,
        }
        impl RESR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - LPM STALL Interrupt Mask"]
            #[inline]
            pub fn stall(&self) -> STALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                STALLR { bits }
            }
            #[doc = "Bit 1 - LPM NY Interrupt Mask"]
            #[inline]
            pub fn ny(&self) -> NYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NYR { bits }
            }
            #[doc = "Bit 2 - LPM ACK Interrupt Mask"]
            #[inline]
            pub fn ack(&self) -> ACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ACKR { bits }
            }
            #[doc = "Bit 3 - LPM NC Interrupt Mask"]
            #[inline]
            pub fn nc(&self) -> NCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NCR { bits }
            }
            #[doc = "Bit 4 - LPM Resume Interrupt Mask"]
            #[inline]
            pub fn res(&self) -> RESR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESR { bits }
            }
            #[doc = "Bit 5 - LPM Error Interrupt Mask"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRR { bits }
            }
        }
    }
    #[doc = "USB LPM Raw Interrupt Status"]
    pub struct LPMRIS {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB LPM Raw Interrupt Status"]
    pub mod lpmris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        impl super::LPMRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct LPMSTR {
            bits: bool,
        }
        impl LPMSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NYR {
            bits: bool,
        }
        impl NYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACKR {
            bits: bool,
        }
        impl ACKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NCR {
            bits: bool,
        }
        impl NCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESR {
            bits: bool,
        }
        impl RESR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRR {
            bits: bool,
        }
        impl ERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bit 0 - LPM STALL Interrupt Status"]
            #[inline]
            pub fn lpmst(&self) -> LPMSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                LPMSTR { bits }
            }
            #[doc = "Bit 1 - LPM NY Interrupt Status"]
            #[inline]
            pub fn ny(&self) -> NYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NYR { bits }
            }
            #[doc = "Bit 2 - LPM ACK Interrupt Status"]
            #[inline]
            pub fn ack(&self) -> ACKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ACKR { bits }
            }
            #[doc = "Bit 3 - LPM NC Interrupt Status"]
            #[inline]
            pub fn nc(&self) -> NCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                NCR { bits }
            }
            #[doc = "Bit 4 - LPM Resume Interrupt Status"]
            #[inline]
            pub fn res(&self) -> RESR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                RESR { bits }
            }
            #[doc = "Bit 5 - LPM Interrupt Status"]
            #[inline]
            pub fn err(&self) -> ERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u8) != 0
                };
                ERRR { bits }
            }
        }
    }
    #[doc = "USB LPM Function Address"]
    pub struct LPMFADDR {
        register: ::vcell::VolatileCell<u8>,
    }
    #[doc = "USB LPM Function Address"]
    pub mod lpmfaddr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u8,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u8,
        }
        impl super::LPMFADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u8,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u8) << OFFSET);
                self.w.bits |= ((value & MASK) as u8) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
            #[doc = "Bits 0:6 - LPM Function Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u8) as u8
                };
                ADDRR { bits }
            }
        }
        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: u8) -> &mut Self {
                self.bits = bits;
                self
            }
            #[doc = "Bits 0:6 - LPM Function Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "USB External Power Control"]
    pub struct EPC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB External Power Control"]
    pub mod epc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EPC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `EPEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EPENR {
            #[doc = "Power Enable Active Low"]
            LOW,
            #[doc = "Power Enable Active High"]
            HIGH,
            #[doc = "Power Enable High if VBUS Low (OTG only)"]
            VBLOW,
            #[doc = "Power Enable High if VBUS High (OTG only)"]
            VBHIGH,
        }
        impl EPENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EPENR::LOW => 0,
                    EPENR::HIGH => 0x01,
                    EPENR::VBLOW => 0x02,
                    EPENR::VBHIGH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EPENR {
                match value {
                    0 => EPENR::LOW,
                    1 => EPENR::HIGH,
                    2 => EPENR::VBLOW,
                    3 => EPENR::VBHIGH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == EPENR::LOW
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == EPENR::HIGH
            }
            #[doc = "Checks if the value of the field is `VBLOW`"]
            #[inline]
            pub fn is_vblow(&self) -> bool {
                *self == EPENR::VBLOW
            }
            #[doc = "Checks if the value of the field is `VBHIGH`"]
            #[inline]
            pub fn is_vbhigh(&self) -> bool {
                *self == EPENR::VBHIGH
            }
        }
        #[doc = r" Value of the field"]
        pub struct EPENDER {
            bits: bool,
        }
        impl EPENDER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFLTENR {
            bits: bool,
        }
        impl PFLTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFLTSEN_HIGHR {
            bits: bool,
        }
        impl PFLTSEN_HIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFLTAENR {
            bits: bool,
        }
        impl PFLTAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PFLTACT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PFLTACTR {
            #[doc = "Unchanged"]
            UNCHG,
            #[doc = "Tristate"]
            TRIS,
            #[doc = "Low"]
            LOW,
            #[doc = "High"]
            HIGH,
        }
        impl PFLTACTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PFLTACTR::UNCHG => 0,
                    PFLTACTR::TRIS => 0x01,
                    PFLTACTR::LOW => 0x02,
                    PFLTACTR::HIGH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PFLTACTR {
                match value {
                    0 => PFLTACTR::UNCHG,
                    1 => PFLTACTR::TRIS,
                    2 => PFLTACTR::LOW,
                    3 => PFLTACTR::HIGH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `UNCHG`"]
            #[inline]
            pub fn is_unchg(&self) -> bool {
                *self == PFLTACTR::UNCHG
            }
            #[doc = "Checks if the value of the field is `TRIS`"]
            #[inline]
            pub fn is_tris(&self) -> bool {
                *self == PFLTACTR::TRIS
            }
            #[doc = "Checks if the value of the field is `LOW`"]
            #[inline]
            pub fn is_low(&self) -> bool {
                *self == PFLTACTR::LOW
            }
            #[doc = "Checks if the value of the field is `HIGH`"]
            #[inline]
            pub fn is_high(&self) -> bool {
                *self == PFLTACTR::HIGH
            }
        }
        #[doc = "Values that can be written to the field `EPEN`"]
        pub enum EPENW {
            #[doc = "Power Enable Active Low"]
            LOW,
            #[doc = "Power Enable Active High"]
            HIGH,
            #[doc = "Power Enable High if VBUS Low (OTG only)"]
            VBLOW,
            #[doc = "Power Enable High if VBUS High (OTG only)"]
            VBHIGH,
        }
        impl EPENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EPENW::LOW => 0,
                    EPENW::HIGH => 1,
                    EPENW::VBLOW => 2,
                    EPENW::VBHIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EPENW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Power Enable Active Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(EPENW::LOW)
            }
            #[doc = "Power Enable Active High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(EPENW::HIGH)
            }
            #[doc = "Power Enable High if VBUS Low (OTG only)"]
            #[inline]
            pub fn vblow(self) -> &'a mut W {
                self.variant(EPENW::VBLOW)
            }
            #[doc = "Power Enable High if VBUS High (OTG only)"]
            #[inline]
            pub fn vbhigh(self) -> &'a mut W {
                self.variant(EPENW::VBHIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPENDEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPENDEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFLTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFLTENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFLTSEN_HIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFLTSEN_HIGHW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFLTAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFLTAENW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PFLTACT`"]
        pub enum PFLTACTW {
            #[doc = "Unchanged"]
            UNCHG,
            #[doc = "Tristate"]
            TRIS,
            #[doc = "Low"]
            LOW,
            #[doc = "High"]
            HIGH,
        }
        impl PFLTACTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PFLTACTW::UNCHG => 0,
                    PFLTACTW::TRIS => 1,
                    PFLTACTW::LOW => 2,
                    PFLTACTW::HIGH => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFLTACTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFLTACTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PFLTACTW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Unchanged"]
            #[inline]
            pub fn unchg(self) -> &'a mut W {
                self.variant(PFLTACTW::UNCHG)
            }
            #[doc = "Tristate"]
            #[inline]
            pub fn tris(self) -> &'a mut W {
                self.variant(PFLTACTW::TRIS)
            }
            #[doc = "Low"]
            #[inline]
            pub fn low(self) -> &'a mut W {
                self.variant(PFLTACTW::LOW)
            }
            #[doc = "High"]
            #[inline]
            pub fn high(self) -> &'a mut W {
                self.variant(PFLTACTW::HIGH)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - External Power Supply Enable Configuration"]
            #[inline]
            pub fn epen(&self) -> EPENR {
                EPENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - EPEN Drive Enable"]
            #[inline]
            pub fn epende(&self) -> EPENDER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EPENDER { bits }
            }
            #[doc = "Bit 4 - Power Fault Input Enable"]
            #[inline]
            pub fn pflten(&self) -> PFLTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFLTENR { bits }
            }
            #[doc = "Bit 5 - Power Fault Sense"]
            #[inline]
            pub fn pfltsen_high(&self) -> PFLTSEN_HIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFLTSEN_HIGHR { bits }
            }
            #[doc = "Bit 6 - Power Fault Action Enable"]
            #[inline]
            pub fn pfltaen(&self) -> PFLTAENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFLTAENR { bits }
            }
            #[doc = "Bits 8:9 - Power Fault Action"]
            #[inline]
            pub fn pfltact(&self) -> PFLTACTR {
                PFLTACTR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - External Power Supply Enable Configuration"]
            #[inline]
            pub fn epen(&mut self) -> _EPENW {
                _EPENW { w: self }
            }
            #[doc = "Bit 2 - EPEN Drive Enable"]
            #[inline]
            pub fn epende(&mut self) -> _EPENDEW {
                _EPENDEW { w: self }
            }
            #[doc = "Bit 4 - Power Fault Input Enable"]
            #[inline]
            pub fn pflten(&mut self) -> _PFLTENW {
                _PFLTENW { w: self }
            }
            #[doc = "Bit 5 - Power Fault Sense"]
            #[inline]
            pub fn pfltsen_high(&mut self) -> _PFLTSEN_HIGHW {
                _PFLTSEN_HIGHW { w: self }
            }
            #[doc = "Bit 6 - Power Fault Action Enable"]
            #[inline]
            pub fn pfltaen(&mut self) -> _PFLTAENW {
                _PFLTAENW { w: self }
            }
            #[doc = "Bits 8:9 - Power Fault Action"]
            #[inline]
            pub fn pfltact(&mut self) -> _PFLTACTW {
                _PFLTACTW { w: self }
            }
        }
    }
    #[doc = "USB External Power Control Raw Interrupt Status"]
    pub struct EPCRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB External Power Control Raw Interrupt Status"]
    pub mod epcris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::EPCRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFR {
            bits: bool,
        }
        impl PFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Power Fault Interrupt Status"]
            #[inline]
            pub fn pf(&self) -> PFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFR { bits }
            }
        }
    }
    #[doc = "USB External Power Control Interrupt Mask"]
    pub struct EPCIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB External Power Control Interrupt Mask"]
    pub mod epcim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EPCIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFR {
            bits: bool,
        }
        impl PFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Power Fault Interrupt Mask"]
            #[inline]
            pub fn pf(&self) -> PFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFR { bits }
            }
        }
        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 = "Bit 0 - USB Power Fault Interrupt Mask"]
            #[inline]
            pub fn pf(&mut self) -> _PFW {
                _PFW { w: self }
            }
        }
    }
    #[doc = "USB External Power Control Interrupt Status and Clear"]
    pub struct EPCISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB External Power Control Interrupt Status and Clear"]
    pub mod epcisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EPCISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFR {
            bits: bool,
        }
        impl PFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PFW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Power Fault Interrupt Status and Clear"]
            #[inline]
            pub fn pf(&self) -> PFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFR { bits }
            }
        }
        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 = "Bit 0 - USB Power Fault Interrupt Status and Clear"]
            #[inline]
            pub fn pf(&mut self) -> _PFW {
                _PFW { w: self }
            }
        }
    }
    #[doc = "USB Device RESUME Raw Interrupt Status"]
    pub struct DRRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Device RESUME Raw Interrupt Status"]
    pub mod drris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::DRRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESUMER {
            bits: bool,
        }
        impl RESUMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RESUME Interrupt Status"]
            #[inline]
            pub fn resume(&self) -> RESUMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RESUMER { bits }
            }
        }
    }
    #[doc = "USB Device RESUME Interrupt Mask"]
    pub struct DRIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Device RESUME Interrupt Mask"]
    pub mod drim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DRIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESUMER {
            bits: bool,
        }
        impl RESUMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESUMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESUMEW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RESUME Interrupt Mask"]
            #[inline]
            pub fn resume(&self) -> RESUMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RESUMER { bits }
            }
        }
        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 = "Bit 0 - RESUME Interrupt Mask"]
            #[inline]
            pub fn resume(&mut self) -> _RESUMEW {
                _RESUMEW { w: self }
            }
        }
    }
    #[doc = "USB Device RESUME Interrupt Status and Clear"]
    pub struct DRISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Device RESUME Interrupt Status and Clear"]
    pub mod drisc {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DRISC {
            #[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 _RESUMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESUMEW<'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 = "Bit 0 - RESUME Interrupt Status and Clear"]
            #[inline]
            pub fn resume(&mut self) -> _RESUMEW {
                _RESUMEW { w: self }
            }
        }
    }
    #[doc = "USB General-Purpose Control and Status"]
    pub struct GPCS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB General-Purpose Control and Status"]
    pub mod gpcs {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::GPCS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `DEVMOD`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DEVMODR {
            #[doc = "Use USB0VBUS and USB0ID pin"]
            OTG,
            #[doc = "Force USB0VBUS and USB0ID low"]
            HOST,
            #[doc = "Force USB0VBUS and USB0ID high"]
            DEV,
            #[doc = "Use USB0VBUS and force USB0ID low"]
            HOSTVBUS,
            #[doc = "Use USB0VBUS and force USB0ID high"]
            DEVVBUS,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DEVMODR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DEVMODR::OTG => 0,
                    DEVMODR::HOST => 0x02,
                    DEVMODR::DEV => 0x03,
                    DEVMODR::HOSTVBUS => 0x04,
                    DEVMODR::DEVVBUS => 0x05,
                    DEVMODR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DEVMODR {
                match value {
                    0 => DEVMODR::OTG,
                    2 => DEVMODR::HOST,
                    3 => DEVMODR::DEV,
                    4 => DEVMODR::HOSTVBUS,
                    5 => DEVMODR::DEVVBUS,
                    i => DEVMODR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OTG`"]
            #[inline]
            pub fn is_otg(&self) -> bool {
                *self == DEVMODR::OTG
            }
            #[doc = "Checks if the value of the field is `HOST`"]
            #[inline]
            pub fn is_host(&self) -> bool {
                *self == DEVMODR::HOST
            }
            #[doc = "Checks if the value of the field is `DEV`"]
            #[inline]
            pub fn is_dev(&self) -> bool {
                *self == DEVMODR::DEV
            }
            #[doc = "Checks if the value of the field is `HOSTVBUS`"]
            #[inline]
            pub fn is_hostvbus(&self) -> bool {
                *self == DEVMODR::HOSTVBUS
            }
            #[doc = "Checks if the value of the field is `DEVVBUS`"]
            #[inline]
            pub fn is_devvbus(&self) -> bool {
                *self == DEVMODR::DEVVBUS
            }
        }
        #[doc = "Values that can be written to the field `DEVMOD`"]
        pub enum DEVMODW {
            #[doc = "Use USB0VBUS and USB0ID pin"]
            OTG,
            #[doc = "Force USB0VBUS and USB0ID low"]
            HOST,
            #[doc = "Force USB0VBUS and USB0ID high"]
            DEV,
            #[doc = "Use USB0VBUS and force USB0ID low"]
            HOSTVBUS,
            #[doc = "Use USB0VBUS and force USB0ID high"]
            DEVVBUS,
        }
        impl DEVMODW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DEVMODW::OTG => 0,
                    DEVMODW::HOST => 2,
                    DEVMODW::DEV => 3,
                    DEVMODW::HOSTVBUS => 4,
                    DEVMODW::DEVVBUS => 5,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DEVMODW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DEVMODW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DEVMODW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use USB0VBUS and USB0ID pin"]
            #[inline]
            pub fn otg(self) -> &'a mut W {
                self.variant(DEVMODW::OTG)
            }
            #[doc = "Force USB0VBUS and USB0ID low"]
            #[inline]
            pub fn host(self) -> &'a mut W {
                self.variant(DEVMODW::HOST)
            }
            #[doc = "Force USB0VBUS and USB0ID high"]
            #[inline]
            pub fn dev(self) -> &'a mut W {
                self.variant(DEVMODW::DEV)
            }
            #[doc = "Use USB0VBUS and force USB0ID low"]
            #[inline]
            pub fn hostvbus(self) -> &'a mut W {
                self.variant(DEVMODW::HOSTVBUS)
            }
            #[doc = "Use USB0VBUS and force USB0ID high"]
            #[inline]
            pub fn devvbus(self) -> &'a mut W {
                self.variant(DEVMODW::DEVVBUS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Device Mode"]
            #[inline]
            pub fn devmod(&self) -> DEVMODR {
                DEVMODR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:2 - Device Mode"]
            #[inline]
            pub fn devmod(&mut self) -> _DEVMODW {
                _DEVMODW { w: self }
            }
        }
    }
    #[doc = "USB VBUS Droop Control"]
    pub struct VDC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB VBUS Droop Control"]
    pub mod vdc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VDC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VBDENR {
            bits: bool,
        }
        impl VBDENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VBDENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VBDENW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - VBUS Droop Enable"]
            #[inline]
            pub fn vbden(&self) -> VBDENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VBDENR { bits }
            }
        }
        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 = "Bit 0 - VBUS Droop Enable"]
            #[inline]
            pub fn vbden(&mut self) -> _VBDENW {
                _VBDENW { w: self }
            }
        }
    }
    #[doc = "USB VBUS Droop Control Raw Interrupt Status"]
    pub struct VDCRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB VBUS Droop Control Raw Interrupt Status"]
    pub mod vdcris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::VDCRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDR {
            bits: bool,
        }
        impl VDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - VBUS Droop Raw Interrupt Status"]
            #[inline]
            pub fn vd(&self) -> VDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDR { bits }
            }
        }
    }
    #[doc = "USB VBUS Droop Control Interrupt Mask"]
    pub struct VDCIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB VBUS Droop Control Interrupt Mask"]
    pub mod vdcim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VDCIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDR {
            bits: bool,
        }
        impl VDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - VBUS Droop Interrupt Mask"]
            #[inline]
            pub fn vd(&self) -> VDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDR { bits }
            }
        }
        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 = "Bit 0 - VBUS Droop Interrupt Mask"]
            #[inline]
            pub fn vd(&mut self) -> _VDW {
                _VDW { w: self }
            }
        }
    }
    #[doc = "USB VBUS Droop Control Interrupt Status and Clear"]
    pub struct VDCISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB VBUS Droop Control Interrupt Status and Clear"]
    pub mod vdcisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VDCISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDR {
            bits: bool,
        }
        impl VDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - VBUS Droop Interrupt Status and Clear"]
            #[inline]
            pub fn vd(&self) -> VDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDR { bits }
            }
        }
        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 = "Bit 0 - VBUS Droop Interrupt Status and Clear"]
            #[inline]
            pub fn vd(&mut self) -> _VDW {
                _VDW { w: self }
            }
        }
    }
    #[doc = "USB Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `TYPE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TYPER {
            #[doc = "The first-generation USB controller"]
            _0,
            #[doc = "Second-generation USB controller.The controller implemented in post Icestorm devices that use the 3.0 version of the Mentor controller"]
            _1,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TYPER::_0 => 0,
                    TYPER::_1 => 0x01,
                    TYPER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TYPER {
                match value {
                    0 => TYPER::_0,
                    1 => TYPER::_1,
                    i => TYPER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == TYPER::_0
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == TYPER::_1
            }
        }
        #[doc = r" Value of the field"]
        pub struct PHYR {
            bits: bool,
        }
        impl PHYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ULPIR {
            bits: bool,
        }
        impl ULPIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `USB`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum USBR {
            #[doc = "DEVICE"]
            DEVICE,
            #[doc = "HOST"]
            HOSTDEVICE,
            #[doc = "OTG"]
            OTG,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl USBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    USBR::DEVICE => 0x01,
                    USBR::HOSTDEVICE => 0x02,
                    USBR::OTG => 0x03,
                    USBR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> USBR {
                match value {
                    1 => USBR::DEVICE,
                    2 => USBR::HOSTDEVICE,
                    3 => USBR::OTG,
                    i => USBR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `DEVICE`"]
            #[inline]
            pub fn is_device(&self) -> bool {
                *self == USBR::DEVICE
            }
            #[doc = "Checks if the value of the field is `HOSTDEVICE`"]
            #[inline]
            pub fn is_hostdevice(&self) -> bool {
                *self == USBR::HOSTDEVICE
            }
            #[doc = "Checks if the value of the field is `OTG`"]
            #[inline]
            pub fn is_otg(&self) -> bool {
                *self == USBR::OTG
            }
        }
        #[doc = r" Value of the field"]
        pub struct ECNTR {
            bits: u8,
        }
        impl ECNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Controller Type"]
            #[inline]
            pub fn type_(&self) -> TYPER {
                TYPER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - PHY Present"]
            #[inline]
            pub fn phy(&self) -> PHYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PHYR { bits }
            }
            #[doc = "Bit 5 - ULPI Present"]
            #[inline]
            pub fn ulpi(&self) -> ULPIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ULPIR { bits }
            }
            #[doc = "Bits 6:7 - USB Capability"]
            #[inline]
            pub fn usb(&self) -> USBR {
                USBR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:15 - Endpoint Count"]
            #[inline]
            pub fn ecnt(&self) -> ECNTR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                ECNTR { bits }
            }
        }
    }
    #[doc = "USB Peripheral Configuration"]
    pub struct PC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Peripheral Configuration"]
    pub mod pc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ULPIENR {
            bits: bool,
        }
        impl ULPIENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ULPIENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ULPIENW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 16 - ULPI Enable"]
            #[inline]
            pub fn ulpien(&self) -> ULPIENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ULPIENR { bits }
            }
        }
        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 = "Bit 16 - ULPI Enable"]
            #[inline]
            pub fn ulpien(&mut self) -> _ULPIENW {
                _ULPIENW { w: self }
            }
        }
    }
    #[doc = "USB Clock Configuration"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Clock Configuration"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKDIVR {
            bits: u8,
        }
        impl CLKDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSDR {
            bits: bool,
        }
        impl CSDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKENR {
            bits: bool,
        }
        impl CLKENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - PLL Clock Divisor"]
            #[inline]
            pub fn clkdiv(&self) -> CLKDIVR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CLKDIVR { bits }
            }
            #[doc = "Bit 8 - Clock Source/Direction"]
            #[inline]
            pub fn csd(&self) -> CSDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSDR { bits }
            }
            #[doc = "Bit 9 - USB Clock Enable"]
            #[inline]
            pub fn clken(&self) -> CLKENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKENR { bits }
            }
        }
    }
}
#[doc = "GPIO register offsets"]
pub struct GPIO_PORTA_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTA_AHB {}
impl GPIO_PORTA_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_8000 as *const _
    }
}
impl Deref for GPIO_PORTA_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTA_AHB::ptr() }
    }
}
#[doc = "GPIO register offsets"]
pub mod gpio_porta_ahb {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        _reserved0: [u8; 1020usize],
        #[doc = "0x3fc - GPIO Data"]
        pub data: DATA,
        #[doc = "0x400 - GPIO Direction"]
        pub dir: DIR,
        #[doc = "0x404 - GPIO Interrupt Sense"]
        pub is: IS,
        #[doc = "0x408 - GPIO Interrupt Both Edges"]
        pub ibe: IBE,
        #[doc = "0x40c - GPIO Interrupt Event"]
        pub iev: IEV,
        #[doc = "0x410 - GPIO Interrupt Mask"]
        pub im: IM,
        #[doc = "0x414 - GPIO Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x418 - GPIO Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x41c - GPIO Interrupt Clear"]
        pub icr: ICR,
        #[doc = "0x420 - GPIO Alternate Function Select"]
        pub afsel: AFSEL,
        _reserved1: [u8; 220usize],
        #[doc = "0x500 - GPIO 2-mA Drive Select"]
        pub dr2r: DR2R,
        #[doc = "0x504 - GPIO 4-mA Drive Select"]
        pub dr4r: DR4R,
        #[doc = "0x508 - GPIO 8-mA Drive Select"]
        pub dr8r: DR8R,
        #[doc = "0x50c - GPIO Open Drain Select"]
        pub odr: ODR,
        #[doc = "0x510 - GPIO Pull-Up Select"]
        pub pur: PUR,
        #[doc = "0x514 - GPIO Pull-Down Select"]
        pub pdr: PDR,
        #[doc = "0x518 - GPIO Slew Rate Control Select"]
        pub slr: SLR,
        #[doc = "0x51c - GPIO Digital Enable"]
        pub den: DEN,
        #[doc = "0x520 - GPIO Lock"]
        pub lock: LOCK,
        #[doc = "0x524 - GPIO Commit"]
        pub cr: CR,
        #[doc = "0x528 - GPIO Analog Mode Select"]
        pub amsel: AMSEL,
        #[doc = "0x52c - GPIO Port Control"]
        pub pctl: PCTL,
        #[doc = "0x530 - GPIO ADC Control"]
        pub adcctl: ADCCTL,
        #[doc = "0x534 - GPIO DMA Control"]
        pub dmactl: DMACTL,
        #[doc = "0x538 - GPIO Select Interrupt"]
        pub si: SI,
        #[doc = "0x53c - GPIO 12-mA Drive Select"]
        pub dr12r: DR12R,
        #[doc = "0x540 - GPIO Wake Pin Enable"]
        pub wakepen: WAKEPEN,
        #[doc = "0x544 - GPIO Wake Level"]
        pub wakelvl: WAKELVL,
        #[doc = "0x548 - GPIO Wake Status"]
        pub wakestat: WAKESTAT,
        _reserved2: [u8; 2676usize],
        #[doc = "0xfc0 - GPIO Peripheral Property"]
        pub pp: PP,
        #[doc = "0xfc4 - GPIO Peripheral Configuration"]
        pub pc: PC,
    }
    #[doc = "GPIO Data"]
    pub struct DATA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Data"]
    pub mod data {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DATA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u8,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DATAR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "GPIO Direction"]
    pub struct DIR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Direction"]
    pub mod dir {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DIR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIRR {
            bits: u8,
        }
        impl DIRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn dir(&self) -> DIRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DIRR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn dir(&mut self) -> _DIRW {
                _DIRW { w: self }
            }
        }
    }
    #[doc = "GPIO Interrupt Sense"]
    pub struct IS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Interrupt Sense"]
    pub mod is {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPIO Interrupt Both Edges"]
    pub struct IBE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Interrupt Both Edges"]
    pub mod ibe {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IBE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPIO Interrupt Event"]
    pub struct IEV {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Interrupt Event"]
    pub mod iev {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IEV {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPIO Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct GPIOR {
            bits: u8,
        }
        impl GPIOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAIMER {
            bits: bool,
        }
        impl DMAIMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _GPIOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GPIOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAIMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAIMEW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPIO Interrupt Mask Enable"]
            #[inline]
            pub fn gpio(&self) -> GPIOR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                GPIOR { bits }
            }
            #[doc = "Bit 8 - GPIO uDMA Done Interrupt Mask Enable"]
            #[inline]
            pub fn dmaime(&self) -> DMAIMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAIMER { bits }
            }
        }
        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 0:7 - GPIO Interrupt Mask Enable"]
            #[inline]
            pub fn gpio(&mut self) -> _GPIOW {
                _GPIOW { w: self }
            }
            #[doc = "Bit 8 - GPIO uDMA Done Interrupt Mask Enable"]
            #[inline]
            pub fn dmaime(&mut self) -> _DMAIMEW {
                _DMAIMEW { w: self }
            }
        }
    }
    #[doc = "GPIO Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct GPIOR {
            bits: u8,
        }
        impl GPIOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARISR {
            bits: bool,
        }
        impl DMARISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPIO Interrupt Raw Status"]
            #[inline]
            pub fn gpio(&self) -> GPIOR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                GPIOR { bits }
            }
            #[doc = "Bit 8 - GPIO uDMA Done Interrupt Raw Status"]
            #[inline]
            pub fn dmaris(&self) -> DMARISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARISR { bits }
            }
        }
    }
    #[doc = "GPIO Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct GPIOR {
            bits: u8,
        }
        impl GPIOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAMISR {
            bits: bool,
        }
        impl DMAMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - GPIO Masked Interrupt Status"]
            #[inline]
            pub fn gpio(&self) -> GPIOR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                GPIOR { bits }
            }
            #[doc = "Bit 8 - GPIO uDMA Done Masked Interrupt Status"]
            #[inline]
            pub fn dmamis(&self) -> DMAMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAMISR { bits }
            }
        }
    }
    #[doc = "GPIO Interrupt Clear"]
    pub struct ICR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Interrupt Clear"]
    pub mod icr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ICR {
            #[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 _GPIOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GPIOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAICW<'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 = 8;
                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 0:7 - GPIO Interrupt Clear"]
            #[inline]
            pub fn gpio(&mut self) -> _GPIOW {
                _GPIOW { w: self }
            }
            #[doc = "Bit 8 - GPIO uDMA Interrupt Clear"]
            #[inline]
            pub fn dmaic(&mut self) -> _DMAICW {
                _DMAICW { w: self }
            }
        }
    }
    #[doc = "GPIO Alternate Function Select"]
    pub struct AFSEL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Alternate Function Select"]
    pub mod afsel {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::AFSEL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct AFSELR {
            bits: u8,
        }
        impl AFSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _AFSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AFSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn afsel(&self) -> AFSELR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                AFSELR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn afsel(&mut self) -> _AFSELW {
                _AFSELW { w: self }
            }
        }
    }
    #[doc = "GPIO 2-mA Drive Select"]
    pub struct DR2R {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO 2-mA Drive Select"]
    pub mod dr2r {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR2R {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DRV2R {
            bits: u8,
        }
        impl DRV2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DRV2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DRV2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn drv2(&self) -> DRV2R {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DRV2R { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn drv2(&mut self) -> _DRV2W {
                _DRV2W { w: self }
            }
        }
    }
    #[doc = "GPIO 4-mA Drive Select"]
    pub struct DR4R {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO 4-mA Drive Select"]
    pub mod dr4r {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR4R {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DRV4R {
            bits: u8,
        }
        impl DRV4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DRV4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DRV4W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn drv4(&self) -> DRV4R {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DRV4R { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn drv4(&mut self) -> _DRV4W {
                _DRV4W { w: self }
            }
        }
    }
    #[doc = "GPIO 8-mA Drive Select"]
    pub struct DR8R {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO 8-mA Drive Select"]
    pub mod dr8r {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR8R {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DRV8R {
            bits: u8,
        }
        impl DRV8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DRV8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DRV8W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn drv8(&self) -> DRV8R {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DRV8R { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn drv8(&mut self) -> _DRV8W {
                _DRV8W { w: self }
            }
        }
    }
    #[doc = "GPIO Open Drain Select"]
    pub struct ODR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Open Drain Select"]
    pub mod odr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ODR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ODER {
            bits: u8,
        }
        impl ODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ODEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn ode(&self) -> ODER {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                ODER { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn ode(&mut self) -> _ODEW {
                _ODEW { w: self }
            }
        }
    }
    #[doc = "GPIO Pull-Up Select"]
    pub struct PUR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Pull-Up Select"]
    pub mod pur {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PUR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PUER {
            bits: u8,
        }
        impl PUER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PUEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PUEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn pue(&self) -> PUER {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PUER { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn pue(&mut self) -> _PUEW {
                _PUEW { w: self }
            }
        }
    }
    #[doc = "GPIO Pull-Down Select"]
    pub struct PDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Pull-Down Select"]
    pub mod pdr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PDER {
            bits: u8,
        }
        impl PDER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PDEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PDEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn pde(&self) -> PDER {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PDER { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn pde(&mut self) -> _PDEW {
                _PDEW { w: self }
            }
        }
    }
    #[doc = "GPIO Slew Rate Control Select"]
    pub struct SLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Slew Rate Control Select"]
    pub mod slr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SLR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SLRR {
            bits: u8,
        }
        impl SLRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn slr(&self) -> SLRR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SLRR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn slr(&mut self) -> _SLRW {
                _SLRW { w: self }
            }
        }
    }
    #[doc = "GPIO Digital Enable"]
    pub struct DEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Digital Enable"]
    pub mod den {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DENR {
            bits: u8,
        }
        impl DENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DENW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn den(&self) -> DENR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DENR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn den(&mut self) -> _DENW {
                _DENW { w: self }
            }
        }
    }
    #[doc = "GPIO Lock"]
    pub struct LOCK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Lock"]
    pub mod lock {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LOCK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `LOCK`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum LOCKR {
            #[doc = "The GPIOCR register is unlocked and may be modified"]
            UNLOCKED,
            #[doc = "The GPIOCR register is locked and may not be modified"]
            LOCKED,
            #[doc = "Unlocks the GPIO_CR register"]
            KEY,
            #[doc = r" Reserved"]
            _Reserved(u32),
        }
        impl LOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                match *self {
                    LOCKR::UNLOCKED => 0,
                    LOCKR::LOCKED => 0x01,
                    LOCKR::KEY => 0x4c4f_434b,
                    LOCKR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u32) -> LOCKR {
                match value {
                    0 => LOCKR::UNLOCKED,
                    1 => LOCKR::LOCKED,
                    1280262987 => LOCKR::KEY,
                    i => LOCKR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `UNLOCKED`"]
            #[inline]
            pub fn is_unlocked(&self) -> bool {
                *self == LOCKR::UNLOCKED
            }
            #[doc = "Checks if the value of the field is `LOCKED`"]
            #[inline]
            pub fn is_locked(&self) -> bool {
                *self == LOCKR::LOCKED
            }
            #[doc = "Checks if the value of the field is `KEY`"]
            #[inline]
            pub fn is_key(&self) -> bool {
                *self == LOCKR::KEY
            }
        }
        #[doc = "Values that can be written to the field `LOCK`"]
        pub enum LOCKW {
            #[doc = "The GPIOCR register is unlocked and may be modified"]
            UNLOCKED,
            #[doc = "The GPIOCR register is locked and may not be modified"]
            LOCKED,
            #[doc = "Unlocks the GPIO_CR register"]
            KEY,
        }
        impl LOCKW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u32 {
                match *self {
                    LOCKW::UNLOCKED => 0,
                    LOCKW::LOCKED => 1,
                    LOCKW::KEY => 1280262987,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOCKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOCKW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: LOCKW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "The GPIOCR register is unlocked and may be modified"]
            #[inline]
            pub fn unlocked(self) -> &'a mut W {
                self.variant(LOCKW::UNLOCKED)
            }
            #[doc = "The GPIOCR register is locked and may not be modified"]
            #[inline]
            pub fn locked(self) -> &'a mut W {
                self.variant(LOCKW::LOCKED)
            }
            #[doc = "Unlocks the GPIO_CR register"]
            #[inline]
            pub fn key(self) -> &'a mut W {
                self.variant(LOCKW::KEY)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - GPIO Lock"]
            #[inline]
            pub fn lock(&self) -> LOCKR {
                LOCKR::_from({
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                })
            }
        }
        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 0:31 - GPIO Lock"]
            #[inline]
            pub fn lock(&mut self) -> _LOCKW {
                _LOCKW { w: self }
            }
        }
    }
    #[doc = "GPIO Commit"]
    pub struct CR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Commit"]
    pub mod cr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "GPIO Analog Mode Select"]
    pub struct AMSEL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Analog Mode Select"]
    pub mod amsel {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::AMSEL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct AMSELR {
            bits: u8,
        }
        impl AMSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _AMSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AMSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn amsel(&self) -> AMSELR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                AMSELR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn amsel(&mut self) -> _AMSELW {
                _AMSELW { w: self }
            }
        }
    }
    #[doc = "GPIO Port Control"]
    pub struct PCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Port Control"]
    pub mod pctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC0R {
            bits: u8,
        }
        impl PMC0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC1R {
            bits: u8,
        }
        impl PMC1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC2R {
            bits: u8,
        }
        impl PMC2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC3R {
            bits: u8,
        }
        impl PMC3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC4R {
            bits: u8,
        }
        impl PMC4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC5R {
            bits: u8,
        }
        impl PMC5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC6R {
            bits: u8,
        }
        impl PMC6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMC7R {
            bits: u8,
        }
        impl PMC7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _PMC3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC4W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC5W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC6W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMC7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMC7W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Port Mux Control 0"]
            #[inline]
            pub fn pmc0(&self) -> PMC0R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC0R { bits }
            }
            #[doc = "Bits 4:7 - Port Mux Control 1"]
            #[inline]
            pub fn pmc1(&self) -> PMC1R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC1R { bits }
            }
            #[doc = "Bits 8:11 - Port Mux Control 2"]
            #[inline]
            pub fn pmc2(&self) -> PMC2R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC2R { bits }
            }
            #[doc = "Bits 12:15 - Port Mux Control 3"]
            #[inline]
            pub fn pmc3(&self) -> PMC3R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC3R { bits }
            }
            #[doc = "Bits 16:19 - Port Mux Control 4"]
            #[inline]
            pub fn pmc4(&self) -> PMC4R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC4R { bits }
            }
            #[doc = "Bits 20:23 - Port Mux Control 5"]
            #[inline]
            pub fn pmc5(&self) -> PMC5R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC5R { bits }
            }
            #[doc = "Bits 24:27 - Port Mux Control 6"]
            #[inline]
            pub fn pmc6(&self) -> PMC6R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC6R { bits }
            }
            #[doc = "Bits 28:31 - Port Mux Control 7"]
            #[inline]
            pub fn pmc7(&self) -> PMC7R {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PMC7R { bits }
            }
        }
        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 0:3 - Port Mux Control 0"]
            #[inline]
            pub fn pmc0(&mut self) -> _PMC0W {
                _PMC0W { w: self }
            }
            #[doc = "Bits 4:7 - Port Mux Control 1"]
            #[inline]
            pub fn pmc1(&mut self) -> _PMC1W {
                _PMC1W { w: self }
            }
            #[doc = "Bits 8:11 - Port Mux Control 2"]
            #[inline]
            pub fn pmc2(&mut self) -> _PMC2W {
                _PMC2W { w: self }
            }
            #[doc = "Bits 12:15 - Port Mux Control 3"]
            #[inline]
            pub fn pmc3(&mut self) -> _PMC3W {
                _PMC3W { w: self }
            }
            #[doc = "Bits 16:19 - Port Mux Control 4"]
            #[inline]
            pub fn pmc4(&mut self) -> _PMC4W {
                _PMC4W { w: self }
            }
            #[doc = "Bits 20:23 - Port Mux Control 5"]
            #[inline]
            pub fn pmc5(&mut self) -> _PMC5W {
                _PMC5W { w: self }
            }
            #[doc = "Bits 24:27 - Port Mux Control 6"]
            #[inline]
            pub fn pmc6(&mut self) -> _PMC6W {
                _PMC6W { w: self }
            }
            #[doc = "Bits 28:31 - Port Mux Control 7"]
            #[inline]
            pub fn pmc7(&mut self) -> _PMC7W {
                _PMC7W { w: self }
            }
        }
    }
    #[doc = "GPIO ADC Control"]
    pub struct ADCCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO ADC Control"]
    pub mod adcctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADCCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADCENR {
            bits: u8,
        }
        impl ADCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADCENW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn adcen(&self) -> ADCENR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                ADCENR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn adcen(&mut self) -> _ADCENW {
                _ADCENW { w: self }
            }
        }
    }
    #[doc = "GPIO DMA Control"]
    pub struct DMACTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO DMA Control"]
    pub mod dmactl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMACTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAENR {
            bits: u8,
        }
        impl DMAENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAENW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn dmaen(&self) -> DMAENR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DMAENR { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn dmaen(&mut self) -> _DMAENW {
                _DMAENW { w: self }
            }
        }
    }
    #[doc = "GPIO Select Interrupt"]
    pub struct SI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Select Interrupt"]
    pub mod si {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SUMR {
            bits: bool,
        }
        impl SUMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SUMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SUMW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Summary Interrupt"]
            #[inline]
            pub fn sum(&self) -> SUMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SUMR { bits }
            }
        }
        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 = "Bit 0 - Summary Interrupt"]
            #[inline]
            pub fn sum(&mut self) -> _SUMW {
                _SUMW { w: self }
            }
        }
    }
    #[doc = "GPIO 12-mA Drive Select"]
    pub struct DR12R {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO 12-mA Drive Select"]
    pub mod dr12r {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DR12R {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DRV12R {
            bits: u8,
        }
        impl DRV12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DRV12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _DRV12W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7"]
            #[inline]
            pub fn drv12(&self) -> DRV12R {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DRV12R { bits }
            }
        }
        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 0:7"]
            #[inline]
            pub fn drv12(&mut self) -> _DRV12W {
                _DRV12W { w: self }
            }
        }
    }
    #[doc = "GPIO Wake Pin Enable"]
    pub struct WAKEPEN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Wake Pin Enable"]
    pub mod wakepen {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::WAKEPEN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAKEP4R {
            bits: bool,
        }
        impl WAKEP4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _WAKEP4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WAKEP4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 4 - P[4] Wake Enable"]
            #[inline]
            pub fn wakep4(&self) -> WAKEP4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WAKEP4R { bits }
            }
        }
        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 = "Bit 4 - P[4] Wake Enable"]
            #[inline]
            pub fn wakep4(&mut self) -> _WAKEP4W {
                _WAKEP4W { w: self }
            }
        }
    }
    #[doc = "GPIO Wake Level"]
    pub struct WAKELVL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Wake Level"]
    pub mod wakelvl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::WAKELVL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAKELVL4R {
            bits: bool,
        }
        impl WAKELVL4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _WAKELVL4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WAKELVL4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 4 - P[4] Wake Level"]
            #[inline]
            pub fn wakelvl4(&self) -> WAKELVL4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WAKELVL4R { bits }
            }
        }
        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 = "Bit 4 - P[4] Wake Level"]
            #[inline]
            pub fn wakelvl4(&mut self) -> _WAKELVL4W {
                _WAKELVL4W { w: self }
            }
        }
    }
    #[doc = "GPIO Wake Status"]
    pub struct WAKESTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Wake Status"]
    pub mod wakestat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::WAKESTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct STAT4R {
            bits: bool,
        }
        impl STAT4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 4 - P[4] Wake Status"]
            #[inline]
            pub fn stat4(&self) -> STAT4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STAT4R { bits }
            }
        }
    }
    #[doc = "GPIO Peripheral Property"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Peripheral Property"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDER {
            bits: bool,
        }
        impl EDER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Extended Drive Enable"]
            #[inline]
            pub fn ede(&self) -> EDER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EDER { bits }
            }
        }
    }
    #[doc = "GPIO Peripheral Configuration"]
    pub struct PC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "GPIO Peripheral Configuration"]
    pub mod pc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `EDM0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EDM0R {
            #[doc = "Drive values of 2, 4 and 8 mA are maintained. GPIO n Drive Select (GPIODRnR) registers function as normal"]
            DISABLE,
            #[doc = "An additional 6 mA option is provided"]
            _6MA,
            #[doc = "A 2 mA driver is always enabled; setting the corresponding GPIODR4R register bit adds 2 mA and setting the corresponding GPIODR8R of GPIODR12R register bit adds an additional 4 mA"]
            PLUS2MA,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EDM0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EDM0R::DISABLE => 0,
                    EDM0R::_6MA => 0x01,
                    EDM0R::PLUS2MA => 0x03,
                    EDM0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EDM0R {
                match value {
                    0 => EDM0R::DISABLE,
                    1 => EDM0R::_6MA,
                    3 => EDM0R::PLUS2MA,
                    i => EDM0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `DISABLE`"]
            #[inline]
            pub fn is_disable(&self) -> bool {
                *self == EDM0R::DISABLE
            }
            #[doc = "Checks if the value of the field is `_6MA`"]
            #[inline]
            pub fn is_6ma(&self) -> bool {
                *self == EDM0R::_6MA
            }
            #[doc = "Checks if the value of the field is `PLUS2MA`"]
            #[inline]
            pub fn is_plus2ma(&self) -> bool {
                *self == EDM0R::PLUS2MA
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM1R {
            bits: u8,
        }
        impl EDM1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM2R {
            bits: u8,
        }
        impl EDM2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM3R {
            bits: u8,
        }
        impl EDM3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM4R {
            bits: u8,
        }
        impl EDM4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM5R {
            bits: u8,
        }
        impl EDM5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM6R {
            bits: u8,
        }
        impl EDM6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EDM7R {
            bits: u8,
        }
        impl EDM7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Values that can be written to the field `EDM0`"]
        pub enum EDM0W {
            #[doc = "Drive values of 2, 4 and 8 mA are maintained. GPIO n Drive Select (GPIODRnR) registers function as normal"]
            DISABLE,
            #[doc = "An additional 6 mA option is provided"]
            _6MA,
            #[doc = "A 2 mA driver is always enabled; setting the corresponding GPIODR4R register bit adds 2 mA and setting the corresponding GPIODR8R of GPIODR12R register bit adds an additional 4 mA"]
            PLUS2MA,
        }
        impl EDM0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EDM0W::DISABLE => 0,
                    EDM0W::_6MA => 1,
                    EDM0W::PLUS2MA => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EDM0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Drive values of 2, 4 and 8 mA are maintained. GPIO n Drive Select (GPIODRnR) registers function as normal"]
            #[inline]
            pub fn disable(self) -> &'a mut W {
                self.variant(EDM0W::DISABLE)
            }
            #[doc = "An additional 6 mA option is provided"]
            #[inline]
            pub fn _6ma(self) -> &'a mut W {
                self.variant(EDM0W::_6MA)
            }
            #[doc = "A 2 mA driver is always enabled; setting the corresponding GPIODR4R register bit adds 2 mA and setting the corresponding GPIODR8R of GPIODR12R register bit adds an additional 4 mA"]
            #[inline]
            pub fn plus2ma(self) -> &'a mut W {
                self.variant(EDM0W::PLUS2MA)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM2W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM3W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM4W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _EDM5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM5W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM6W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EDM7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EDM7W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Extended Drive Mode Bit 0"]
            #[inline]
            pub fn edm0(&self) -> EDM0R {
                EDM0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Extended Drive Mode Bit 1"]
            #[inline]
            pub fn edm1(&self) -> EDM1R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM1R { bits }
            }
            #[doc = "Bits 4:5 - Extended Drive Mode Bit 2"]
            #[inline]
            pub fn edm2(&self) -> EDM2R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM2R { bits }
            }
            #[doc = "Bits 6:7 - Extended Drive Mode Bit 3"]
            #[inline]
            pub fn edm3(&self) -> EDM3R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM3R { bits }
            }
            #[doc = "Bits 8:9 - Extended Drive Mode Bit 4"]
            #[inline]
            pub fn edm4(&self) -> EDM4R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM4R { bits }
            }
            #[doc = "Bits 10:11 - Extended Drive Mode Bit 5"]
            #[inline]
            pub fn edm5(&self) -> EDM5R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM5R { bits }
            }
            #[doc = "Bits 12:13 - Extended Drive Mode Bit 6"]
            #[inline]
            pub fn edm6(&self) -> EDM6R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM6R { bits }
            }
            #[doc = "Bits 14:15 - Extended Drive Mode Bit 7"]
            #[inline]
            pub fn edm7(&self) -> EDM7R {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EDM7R { bits }
            }
        }
        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 0:1 - Extended Drive Mode Bit 0"]
            #[inline]
            pub fn edm0(&mut self) -> _EDM0W {
                _EDM0W { w: self }
            }
            #[doc = "Bits 2:3 - Extended Drive Mode Bit 1"]
            #[inline]
            pub fn edm1(&mut self) -> _EDM1W {
                _EDM1W { w: self }
            }
            #[doc = "Bits 4:5 - Extended Drive Mode Bit 2"]
            #[inline]
            pub fn edm2(&mut self) -> _EDM2W {
                _EDM2W { w: self }
            }
            #[doc = "Bits 6:7 - Extended Drive Mode Bit 3"]
            #[inline]
            pub fn edm3(&mut self) -> _EDM3W {
                _EDM3W { w: self }
            }
            #[doc = "Bits 8:9 - Extended Drive Mode Bit 4"]
            #[inline]
            pub fn edm4(&mut self) -> _EDM4W {
                _EDM4W { w: self }
            }
            #[doc = "Bits 10:11 - Extended Drive Mode Bit 5"]
            #[inline]
            pub fn edm5(&mut self) -> _EDM5W {
                _EDM5W { w: self }
            }
            #[doc = "Bits 12:13 - Extended Drive Mode Bit 6"]
            #[inline]
            pub fn edm6(&mut self) -> _EDM6W {
                _EDM6W { w: self }
            }
            #[doc = "Bits 14:15 - Extended Drive Mode Bit 7"]
            #[inline]
            pub fn edm7(&mut self) -> _EDM7W {
                _EDM7W { w: self }
            }
        }
    }
}
#[doc = "GPIO_PORTB_AHB"]
pub struct GPIO_PORTB_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTB_AHB {}
impl GPIO_PORTB_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_9000 as *const _
    }
}
impl Deref for GPIO_PORTB_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTB_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTC_AHB"]
pub struct GPIO_PORTC_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTC_AHB {}
impl GPIO_PORTC_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_a000 as *const _
    }
}
impl Deref for GPIO_PORTC_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTC_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTD_AHB"]
pub struct GPIO_PORTD_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTD_AHB {}
impl GPIO_PORTD_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_b000 as *const _
    }
}
impl Deref for GPIO_PORTD_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTD_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTE_AHB"]
pub struct GPIO_PORTE_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTE_AHB {}
impl GPIO_PORTE_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_c000 as *const _
    }
}
impl Deref for GPIO_PORTE_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTE_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTF_AHB"]
pub struct GPIO_PORTF_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTF_AHB {}
impl GPIO_PORTF_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_d000 as *const _
    }
}
impl Deref for GPIO_PORTF_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTF_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTG_AHB"]
pub struct GPIO_PORTG_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTG_AHB {}
impl GPIO_PORTG_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_e000 as *const _
    }
}
impl Deref for GPIO_PORTG_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTG_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTH_AHB"]
pub struct GPIO_PORTH_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTH_AHB {}
impl GPIO_PORTH_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4005_f000 as *const _
    }
}
impl Deref for GPIO_PORTH_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTH_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTJ_AHB"]
pub struct GPIO_PORTJ_AHB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTJ_AHB {}
impl GPIO_PORTJ_AHB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_0000 as *const _
    }
}
impl Deref for GPIO_PORTJ_AHB {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTJ_AHB::ptr() }
    }
}
#[doc = "GPIO_PORTK"]
pub struct GPIO_PORTK {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTK {}
impl GPIO_PORTK {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_1000 as *const _
    }
}
impl Deref for GPIO_PORTK {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTK::ptr() }
    }
}
#[doc = "GPIO_PORTL"]
pub struct GPIO_PORTL {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTL {}
impl GPIO_PORTL {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_2000 as *const _
    }
}
impl Deref for GPIO_PORTL {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTL::ptr() }
    }
}
#[doc = "GPIO_PORTM"]
pub struct GPIO_PORTM {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTM {}
impl GPIO_PORTM {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_3000 as *const _
    }
}
impl Deref for GPIO_PORTM {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTM::ptr() }
    }
}
#[doc = "GPIO_PORTN"]
pub struct GPIO_PORTN {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTN {}
impl GPIO_PORTN {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_4000 as *const _
    }
}
impl Deref for GPIO_PORTN {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTN::ptr() }
    }
}
#[doc = "GPIO_PORTP"]
pub struct GPIO_PORTP {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTP {}
impl GPIO_PORTP {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_5000 as *const _
    }
}
impl Deref for GPIO_PORTP {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTP::ptr() }
    }
}
#[doc = "GPIO_PORTQ"]
pub struct GPIO_PORTQ {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for GPIO_PORTQ {}
impl GPIO_PORTQ {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const gpio_porta_ahb::RegisterBlock {
        0x4006_6000 as *const _
    }
}
impl Deref for GPIO_PORTQ {
    type Target = gpio_porta_ahb::RegisterBlock;
    fn deref(&self) -> &gpio_porta_ahb::RegisterBlock {
        unsafe { &*GPIO_PORTQ::ptr() }
    }
}
#[doc = "EEPROM register offsets"]
pub struct EEPROM {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EEPROM {}
impl EEPROM {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const eeprom::RegisterBlock {
        0x400a_f000 as *const _
    }
}
impl Deref for EEPROM {
    type Target = eeprom::RegisterBlock;
    fn deref(&self) -> &eeprom::RegisterBlock {
        unsafe { &*EEPROM::ptr() }
    }
}
#[doc = "EEPROM register offsets"]
pub mod eeprom {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - EEPROM Size Information"]
        pub eesize: EESIZE,
        #[doc = "0x04 - EEPROM Current Block"]
        pub eeblock: EEBLOCK,
        #[doc = "0x08 - EEPROM Current Offset"]
        pub eeoffset: EEOFFSET,
        _reserved0: [u8; 4usize],
        #[doc = "0x10 - EEPROM Read-Write"]
        pub eerdwr: EERDWR,
        #[doc = "0x14 - EEPROM Read-Write with Increment"]
        pub eerdwrinc: EERDWRINC,
        #[doc = "0x18 - EEPROM Done Status"]
        pub eedone: EEDONE,
        #[doc = "0x1c - EEPROM Support Control and Status"]
        pub eesupp: EESUPP,
        #[doc = "0x20 - EEPROM Unlock"]
        pub eeunlock: EEUNLOCK,
        _reserved1: [u8; 12usize],
        #[doc = "0x30 - EEPROM Protection"]
        pub eeprot: EEPROT,
        #[doc = "0x34 - EEPROM Password"]
        pub eepass0: EEPASS0,
        #[doc = "0x38 - EEPROM Password"]
        pub eepass1: EEPASS1,
        #[doc = "0x3c - EEPROM Password"]
        pub eepass2: EEPASS2,
        #[doc = "0x40 - EEPROM Interrupt"]
        pub eeint: EEINT,
        _reserved2: [u8; 12usize],
        #[doc = "0x50 - EEPROM Block Hide 0"]
        pub eehide0: EEHIDE0,
        #[doc = "0x54 - EEPROM Block Hide 1"]
        pub eehide1: EEHIDE1,
        #[doc = "0x58 - EEPROM Block Hide 2"]
        pub eehide2: EEHIDE2,
        _reserved3: [u8; 36usize],
        #[doc = "0x80 - EEPROM Debug Mass Erase"]
        pub eedbgme: EEDBGME,
        _reserved4: [u8; 3900usize],
        #[doc = "0xfc0 - EEPROM Peripheral Properties"]
        pub pp: PP,
    }
    #[doc = "EEPROM Size Information"]
    pub struct EESIZE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Size Information"]
    pub mod eesize {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::EESIZE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WORDCNTR {
            bits: u16,
        }
        impl WORDCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct BLKCNTR {
            bits: u16,
        }
        impl BLKCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Number of 32-Bit Words"]
            #[inline]
            pub fn wordcnt(&self) -> WORDCNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                WORDCNTR { bits }
            }
            #[doc = "Bits 16:26 - Number of 16-Word Blocks"]
            #[inline]
            pub fn blkcnt(&self) -> BLKCNTR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                BLKCNTR { bits }
            }
        }
    }
    #[doc = "EEPROM Current Block"]
    pub struct EEBLOCK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Current Block"]
    pub mod eeblock {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEBLOCK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BLOCKR {
            bits: u16,
        }
        impl BLOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _BLOCKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BLOCKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Current Block"]
            #[inline]
            pub fn block(&self) -> BLOCKR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                BLOCKR { bits }
            }
        }
        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 0:15 - Current Block"]
            #[inline]
            pub fn block(&mut self) -> _BLOCKW {
                _BLOCKW { w: self }
            }
        }
    }
    #[doc = "EEPROM Current Offset"]
    pub struct EEOFFSET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Current Offset"]
    pub mod eeoffset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEOFFSET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct OFFSETR {
            bits: u8,
        }
        impl OFFSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _OFFSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OFFSETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Current Address Offset"]
            #[inline]
            pub fn offset(&self) -> OFFSETR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                OFFSETR { bits }
            }
        }
        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 0:3 - Current Address Offset"]
            #[inline]
            pub fn offset(&mut self) -> _OFFSETW {
                _OFFSETW { w: self }
            }
        }
    }
    #[doc = "EEPROM Read-Write"]
    pub struct EERDWR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Read-Write"]
    pub mod eerdwr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EERDWR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VALUER {
            bits: u32,
        }
        impl VALUER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _VALUEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VALUEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - EEPROM Read or Write Data"]
            #[inline]
            pub fn value(&self) -> VALUER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                VALUER { bits }
            }
        }
        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 0:31 - EEPROM Read or Write Data"]
            #[inline]
            pub fn value(&mut self) -> _VALUEW {
                _VALUEW { w: self }
            }
        }
    }
    #[doc = "EEPROM Read-Write with Increment"]
    pub struct EERDWRINC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Read-Write with Increment"]
    pub mod eerdwrinc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EERDWRINC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VALUER {
            bits: u32,
        }
        impl VALUER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _VALUEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VALUEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - EEPROM Read or Write Data with Increment"]
            #[inline]
            pub fn value(&self) -> VALUER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                VALUER { bits }
            }
        }
        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 0:31 - EEPROM Read or Write Data with Increment"]
            #[inline]
            pub fn value(&mut self) -> _VALUEW {
                _VALUEW { w: self }
            }
        }
    }
    #[doc = "EEPROM Done Status"]
    pub struct EEDONE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Done Status"]
    pub mod eedone {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::EEDONE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WORKINGR {
            bits: bool,
        }
        impl WORKINGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WKERASER {
            bits: bool,
        }
        impl WKERASER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WKCOPYR {
            bits: bool,
        }
        impl WKCOPYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NOPERMR {
            bits: bool,
        }
        impl NOPERMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRBUSYR {
            bits: bool,
        }
        impl WRBUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Working"]
            #[inline]
            pub fn working(&self) -> WORKINGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WORKINGR { bits }
            }
            #[doc = "Bit 2 - Working on an Erase"]
            #[inline]
            pub fn wkerase(&self) -> WKERASER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WKERASER { bits }
            }
            #[doc = "Bit 3 - Working on a Copy"]
            #[inline]
            pub fn wkcopy(&self) -> WKCOPYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WKCOPYR { bits }
            }
            #[doc = "Bit 4 - Write Without Permission"]
            #[inline]
            pub fn noperm(&self) -> NOPERMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NOPERMR { bits }
            }
            #[doc = "Bit 5 - Write Busy"]
            #[inline]
            pub fn wrbusy(&self) -> WRBUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRBUSYR { bits }
            }
        }
    }
    #[doc = "EEPROM Support Control and Status"]
    pub struct EESUPP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Support Control and Status"]
    pub mod eesupp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EESUPP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERETRYR {
            bits: bool,
        }
        impl ERETRYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PRETRYR {
            bits: bool,
        }
        impl PRETRYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERETRYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERETRYW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PRETRYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PRETRYW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 2 - Erase Must Be Retried"]
            #[inline]
            pub fn eretry(&self) -> ERETRYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERETRYR { bits }
            }
            #[doc = "Bit 3 - Programming Must Be Retried"]
            #[inline]
            pub fn pretry(&self) -> PRETRYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PRETRYR { bits }
            }
        }
        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 = "Bit 2 - Erase Must Be Retried"]
            #[inline]
            pub fn eretry(&mut self) -> _ERETRYW {
                _ERETRYW { w: self }
            }
            #[doc = "Bit 3 - Programming Must Be Retried"]
            #[inline]
            pub fn pretry(&mut self) -> _PRETRYW {
                _PRETRYW { w: self }
            }
        }
    }
    #[doc = "EEPROM Unlock"]
    pub struct EEUNLOCK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Unlock"]
    pub mod eeunlock {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEUNLOCK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNLOCKR {
            bits: u32,
        }
        impl UNLOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNLOCKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNLOCKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - EEPROM Unlock"]
            #[inline]
            pub fn unlock(&self) -> UNLOCKR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                UNLOCKR { bits }
            }
        }
        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 0:31 - EEPROM Unlock"]
            #[inline]
            pub fn unlock(&mut self) -> _UNLOCKW {
                _UNLOCKW { w: self }
            }
        }
    }
    #[doc = "EEPROM Protection"]
    pub struct EEPROT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Protection"]
    pub mod eeprot {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEPROT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PROT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PROTR {
            #[doc = "This setting is the default. If there is no password, the block is not protected and is readable and writable"]
            RWNPW,
            #[doc = "If there is a password, the block is readable or writable only when unlocked"]
            RWPW,
            #[doc = "If there is no password, the block is readable, not writable"]
            RONPW,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PROTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PROTR::RWNPW => 0,
                    PROTR::RWPW => 0x01,
                    PROTR::RONPW => 0x02,
                    PROTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PROTR {
                match value {
                    0 => PROTR::RWNPW,
                    1 => PROTR::RWPW,
                    2 => PROTR::RONPW,
                    i => PROTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `RWNPW`"]
            #[inline]
            pub fn is_rwnpw(&self) -> bool {
                *self == PROTR::RWNPW
            }
            #[doc = "Checks if the value of the field is `RWPW`"]
            #[inline]
            pub fn is_rwpw(&self) -> bool {
                *self == PROTR::RWPW
            }
            #[doc = "Checks if the value of the field is `RONPW`"]
            #[inline]
            pub fn is_ronpw(&self) -> bool {
                *self == PROTR::RONPW
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACCR {
            bits: bool,
        }
        impl ACCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `PROT`"]
        pub enum PROTW {
            #[doc = "This setting is the default. If there is no password, the block is not protected and is readable and writable"]
            RWNPW,
            #[doc = "If there is a password, the block is readable or writable only when unlocked"]
            RWPW,
            #[doc = "If there is no password, the block is readable, not writable"]
            RONPW,
        }
        impl PROTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PROTW::RWNPW => 0,
                    PROTW::RWPW => 1,
                    PROTW::RONPW => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PROTW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "This setting is the default. If there is no password, the block is not protected and is readable and writable"]
            #[inline]
            pub fn rwnpw(self) -> &'a mut W {
                self.variant(PROTW::RWNPW)
            }
            #[doc = "If there is a password, the block is readable or writable only when unlocked"]
            #[inline]
            pub fn rwpw(self) -> &'a mut W {
                self.variant(PROTW::RWPW)
            }
            #[doc = "If there is no password, the block is readable, not writable"]
            #[inline]
            pub fn ronpw(self) -> &'a mut W {
                self.variant(PROTW::RONPW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACCW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Protection Control"]
            #[inline]
            pub fn prot(&self) -> PROTR {
                PROTR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 3 - Access Control"]
            #[inline]
            pub fn acc(&self) -> ACCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACCR { bits }
            }
        }
        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 0:2 - Protection Control"]
            #[inline]
            pub fn prot(&mut self) -> _PROTW {
                _PROTW { w: self }
            }
            #[doc = "Bit 3 - Access Control"]
            #[inline]
            pub fn acc(&mut self) -> _ACCW {
                _ACCW { w: self }
            }
        }
    }
    #[doc = "EEPROM Password"]
    pub struct EEPASS0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Password"]
    pub mod eepass0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEPASS0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PASSR {
            bits: u32,
        }
        impl PASSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PASSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PASSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Password"]
            #[inline]
            pub fn pass(&self) -> PASSR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PASSR { bits }
            }
        }
        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 0:31 - Password"]
            #[inline]
            pub fn pass(&mut self) -> _PASSW {
                _PASSW { w: self }
            }
        }
    }
    #[doc = "EEPROM Password"]
    pub struct EEPASS1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Password"]
    pub mod eepass1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEPASS1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PASSR {
            bits: u32,
        }
        impl PASSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PASSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PASSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Password"]
            #[inline]
            pub fn pass(&self) -> PASSR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PASSR { bits }
            }
        }
        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 0:31 - Password"]
            #[inline]
            pub fn pass(&mut self) -> _PASSW {
                _PASSW { w: self }
            }
        }
    }
    #[doc = "EEPROM Password"]
    pub struct EEPASS2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Password"]
    pub mod eepass2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEPASS2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PASSR {
            bits: u32,
        }
        impl PASSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PASSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PASSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Password"]
            #[inline]
            pub fn pass(&self) -> PASSR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PASSR { bits }
            }
        }
        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 0:31 - Password"]
            #[inline]
            pub fn pass(&mut self) -> _PASSW {
                _PASSW { w: self }
            }
        }
    }
    #[doc = "EEPROM Interrupt"]
    pub struct EEINT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Interrupt"]
    pub mod eeint {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEINT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTR {
            bits: bool,
        }
        impl INTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Interrupt Enable"]
            #[inline]
            pub fn int(&self) -> INTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTR { bits }
            }
        }
        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 = "Bit 0 - Interrupt Enable"]
            #[inline]
            pub fn int(&mut self) -> _INTW {
                _INTW { w: self }
            }
        }
    }
    #[doc = "EEPROM Block Hide 0"]
    pub struct EEHIDE0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Block Hide 0"]
    pub mod eehide0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEHIDE0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HNR {
            bits: u32,
        }
        impl HNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HNW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x7fff_ffff;
                const OFFSET: u8 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 1:31 - Hide Block"]
            #[inline]
            pub fn hn(&self) -> HNR {
                let bits = {
                    const MASK: u32 = 0x7fff_ffff;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HNR { bits }
            }
        }
        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 1:31 - Hide Block"]
            #[inline]
            pub fn hn(&mut self) -> _HNW {
                _HNW { w: self }
            }
        }
    }
    #[doc = "EEPROM Block Hide 1"]
    pub struct EEHIDE1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Block Hide 1"]
    pub mod eehide1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEHIDE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HNR {
            bits: u32,
        }
        impl HNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HNW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Hide Block"]
            #[inline]
            pub fn hn(&self) -> HNR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HNR { bits }
            }
        }
        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 0:31 - Hide Block"]
            #[inline]
            pub fn hn(&mut self) -> _HNW {
                _HNW { w: self }
            }
        }
    }
    #[doc = "EEPROM Block Hide 2"]
    pub struct EEHIDE2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Block Hide 2"]
    pub mod eehide2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEHIDE2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HNR {
            bits: u32,
        }
        impl HNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HNW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Hide Block"]
            #[inline]
            pub fn hn(&self) -> HNR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HNR { bits }
            }
        }
        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 0:31 - Hide Block"]
            #[inline]
            pub fn hn(&mut self) -> _HNW {
                _HNW { w: self }
            }
        }
    }
    #[doc = "EEPROM Debug Mass Erase"]
    pub struct EEDBGME {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Debug Mass Erase"]
    pub mod eedbgme {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EEDBGME {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MER {
            bits: bool,
        }
        impl MER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct KEYR {
            bits: u16,
        }
        impl KEYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _KEYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _KEYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Mass Erase"]
            #[inline]
            pub fn me(&self) -> MER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MER { bits }
            }
            #[doc = "Bits 16:31 - Erase Key"]
            #[inline]
            pub fn key(&self) -> KEYR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                KEYR { bits }
            }
        }
        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 = "Bit 0 - Mass Erase"]
            #[inline]
            pub fn me(&mut self) -> _MEW {
                _MEW { w: self }
            }
            #[doc = "Bits 16:31 - Erase Key"]
            #[inline]
            pub fn key(&mut self) -> _KEYW {
                _KEYW { w: self }
            }
        }
    }
    #[doc = "EEPROM Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "64 bytes of EEPROM"]
            _64,
            #[doc = "128 bytes of EEPROM"]
            _128,
            #[doc = "256 bytes of EEPROM"]
            _256,
            #[doc = "512 bytes of EEPROM"]
            _512,
            #[doc = "1 KB of EEPROM"]
            _1K,
            #[doc = "2 KB of EEPROM"]
            _2K,
            #[doc = "3 KB of EEPROM"]
            _3K,
            #[doc = "4 KB of EEPROM"]
            _4K,
            #[doc = "5 KB of EEPROM"]
            _5K,
            #[doc = "6 KB of EEPROM"]
            _6K,
            #[doc = r" Reserved"]
            _Reserved(u16),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                match *self {
                    SIZER::_64 => 0,
                    SIZER::_128 => 0x01,
                    SIZER::_256 => 0x03,
                    SIZER::_512 => 0x07,
                    SIZER::_1K => 0x0f,
                    SIZER::_2K => 0x1f,
                    SIZER::_3K => 0x3f,
                    SIZER::_4K => 0x7f,
                    SIZER::_5K => 0xff,
                    SIZER::_6K => 0x01ff,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u16) -> SIZER {
                match value {
                    0 => SIZER::_64,
                    1 => SIZER::_128,
                    3 => SIZER::_256,
                    7 => SIZER::_512,
                    15 => SIZER::_1K,
                    31 => SIZER::_2K,
                    63 => SIZER::_3K,
                    127 => SIZER::_4K,
                    255 => SIZER::_5K,
                    511 => SIZER::_6K,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == SIZER::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == SIZER::_128
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == SIZER::_256
            }
            #[doc = "Checks if the value of the field is `_512`"]
            #[inline]
            pub fn is_512(&self) -> bool {
                *self == SIZER::_512
            }
            #[doc = "Checks if the value of the field is `_1K`"]
            #[inline]
            pub fn is_1k(&self) -> bool {
                *self == SIZER::_1K
            }
            #[doc = "Checks if the value of the field is `_2K`"]
            #[inline]
            pub fn is_2k(&self) -> bool {
                *self == SIZER::_2K
            }
            #[doc = "Checks if the value of the field is `_3K`"]
            #[inline]
            pub fn is_3k(&self) -> bool {
                *self == SIZER::_3K
            }
            #[doc = "Checks if the value of the field is `_4K`"]
            #[inline]
            pub fn is_4k(&self) -> bool {
                *self == SIZER::_4K
            }
            #[doc = "Checks if the value of the field is `_5K`"]
            #[inline]
            pub fn is_5k(&self) -> bool {
                *self == SIZER::_5K
            }
            #[doc = "Checks if the value of the field is `_6K`"]
            #[inline]
            pub fn is_6k(&self) -> bool {
                *self == SIZER::_6K
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - EEPROM Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                })
            }
        }
    }
}
#[doc = "I2C8"]
pub struct I2C8 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C8 {}
impl I2C8 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400b_8000 as *const _
    }
}
impl Deref for I2C8 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C8::ptr() }
    }
}
#[doc = "I2C9"]
pub struct I2C9 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C9 {}
impl I2C9 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400b_9000 as *const _
    }
}
impl Deref for I2C9 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C9::ptr() }
    }
}
#[doc = "I2C4"]
pub struct I2C4 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C4 {}
impl I2C4 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400c_0000 as *const _
    }
}
impl Deref for I2C4 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C4::ptr() }
    }
}
#[doc = "I2C5"]
pub struct I2C5 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C5 {}
impl I2C5 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400c_1000 as *const _
    }
}
impl Deref for I2C5 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C5::ptr() }
    }
}
#[doc = "I2C6"]
pub struct I2C6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C6 {}
impl I2C6 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400c_2000 as *const _
    }
}
impl Deref for I2C6 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C6::ptr() }
    }
}
#[doc = "I2C7"]
pub struct I2C7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for I2C7 {}
impl I2C7 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const i2c0::RegisterBlock {
        0x400c_3000 as *const _
    }
}
impl Deref for I2C7 {
    type Target = i2c0::RegisterBlock;
    fn deref(&self) -> &i2c0::RegisterBlock {
        unsafe { &*I2C7::ptr() }
    }
}
#[doc = "External Peripheral Interface register offsets"]
pub struct EPI0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EPI0 {}
impl EPI0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const epi0::RegisterBlock {
        0x400d_0000 as *const _
    }
}
impl Deref for EPI0 {
    type Target = epi0::RegisterBlock;
    fn deref(&self) -> &epi0::RegisterBlock {
        unsafe { &*EPI0::ptr() }
    }
}
#[doc = "External Peripheral Interface register offsets"]
pub mod epi0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - EPI Configuration"]
        pub cfg: CFG,
        #[doc = "0x04 - EPI Main Baud Rate"]
        pub baud: BAUD,
        #[doc = "0x08 - EPI Main Baud Rate"]
        pub baud2: BAUD2,
        _reserved0: [u8; 4usize],
        #[doc = "0x10 - EPI Host-Bus 16 Configuration"]
        pub hb16cfg: HB16CFG,
        #[doc = "0x14 - EPI Host-Bus 8 Configuration 2"]
        pub hb8cfg2: HB8CFG2,
        _reserved1: [u8; 4usize],
        #[doc = "0x1c - EPI Address Map"]
        pub addrmap: ADDRMAP,
        #[doc = "0x20 - EPI Read Size 0"]
        pub rsize0: RSIZE0,
        #[doc = "0x24 - EPI Read Address 0"]
        pub raddr0: RADDR0,
        #[doc = "0x28 - EPI Non-Blocking Read Data 0"]
        pub rpstd0: RPSTD0,
        _reserved2: [u8; 4usize],
        #[doc = "0x30 - EPI Read Size 1"]
        pub rsize1: RSIZE1,
        #[doc = "0x34 - EPI Read Address 1"]
        pub raddr1: RADDR1,
        #[doc = "0x38 - EPI Non-Blocking Read Data 1"]
        pub rpstd1: RPSTD1,
        _reserved3: [u8; 36usize],
        #[doc = "0x60 - EPI Status"]
        pub stat: STAT,
        _reserved4: [u8; 8usize],
        #[doc = "0x6c - EPI Read FIFO Count"]
        pub rfifocnt: RFIFOCNT,
        #[doc = "0x70 - EPI Read FIFO"]
        pub readfifo0: READFIFO0,
        #[doc = "0x74 - EPI Read FIFO Alias 1"]
        pub readfifo1: READFIFO1,
        #[doc = "0x78 - EPI Read FIFO Alias 2"]
        pub readfifo2: READFIFO2,
        #[doc = "0x7c - EPI Read FIFO Alias 3"]
        pub readfifo3: READFIFO3,
        #[doc = "0x80 - EPI Read FIFO Alias 4"]
        pub readfifo4: READFIFO4,
        #[doc = "0x84 - EPI Read FIFO Alias 5"]
        pub readfifo5: READFIFO5,
        #[doc = "0x88 - EPI Read FIFO Alias 6"]
        pub readfifo6: READFIFO6,
        #[doc = "0x8c - EPI Read FIFO Alias 7"]
        pub readfifo7: READFIFO7,
        _reserved5: [u8; 368usize],
        #[doc = "0x200 - EPI FIFO Level Selects"]
        pub fifolvl: FIFOLVL,
        #[doc = "0x204 - EPI Write FIFO Count"]
        pub wfifocnt: WFIFOCNT,
        #[doc = "0x208 - EPI DMA Transmit Count"]
        pub dmatxcnt: DMATXCNT,
        _reserved6: [u8; 4usize],
        #[doc = "0x210 - EPI Interrupt Mask"]
        pub im: IM,
        #[doc = "0x214 - EPI Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x218 - EPI Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x21c - EPI Error and Interrupt Status and Clear"]
        pub eisc: EISC,
        _reserved7: [u8; 232usize],
        #[doc = "0x308 - EPI Host-Bus 8 Configuration 3"]
        pub hb8cfg3: HB8CFG3,
        #[doc = "0x30c - EPI Host-Bus 16 Configuration 4"]
        pub hb16cfg4: HB16CFG4,
        #[doc = "0x310 - EPI Host-Bus 8 Timing Extension"]
        pub hb8time: HB8TIME,
        #[doc = "0x314 - EPI Host-Bus 8 Timing Extension"]
        pub hb8time2: HB8TIME2,
        #[doc = "0x318 - EPI Host-Bus 16 Timing Extension"]
        pub hb16time3: HB16TIME3,
        #[doc = "0x31c - EPI Host-Bus 8 Timing Extension"]
        pub hb8time4: HB8TIME4,
        _reserved8: [u8; 64usize],
        #[doc = "0x360 - EPI Host-Bus PSRAM"]
        pub hbpsram: HBPSRAM,
    }
    #[doc = "EPI Configuration"]
    pub struct CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Configuration"]
    pub mod cfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "General Purpose"]
            NONE,
            #[doc = "SDRAM"]
            SDRAM,
            #[doc = "8-Bit Host-Bus (HB8)"]
            HB8,
            #[doc = "16-Bit Host-Bus (HB16)"]
            HB16,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::NONE => 0,
                    MODER::SDRAM => 0x01,
                    MODER::HB8 => 0x02,
                    MODER::HB16 => 0x03,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::NONE,
                    1 => MODER::SDRAM,
                    2 => MODER::HB8,
                    3 => MODER::HB16,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == MODER::NONE
            }
            #[doc = "Checks if the value of the field is `SDRAM`"]
            #[inline]
            pub fn is_sdram(&self) -> bool {
                *self == MODER::SDRAM
            }
            #[doc = "Checks if the value of the field is `HB8`"]
            #[inline]
            pub fn is_hb8(&self) -> bool {
                *self == MODER::HB8
            }
            #[doc = "Checks if the value of the field is `HB16`"]
            #[inline]
            pub fn is_hb16(&self) -> bool {
                *self == MODER::HB16
            }
        }
        #[doc = r" Value of the field"]
        pub struct BLKENR {
            bits: bool,
        }
        impl BLKENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTDIVR {
            bits: bool,
        }
        impl INTDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "General Purpose"]
            NONE,
            #[doc = "SDRAM"]
            SDRAM,
            #[doc = "8-Bit Host-Bus (HB8)"]
            HB8,
            #[doc = "16-Bit Host-Bus (HB16)"]
            HB16,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::NONE => 0,
                    MODEW::SDRAM => 1,
                    MODEW::HB8 => 2,
                    MODEW::HB16 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "General Purpose"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(MODEW::NONE)
            }
            #[doc = "SDRAM"]
            #[inline]
            pub fn sdram(self) -> &'a mut W {
                self.variant(MODEW::SDRAM)
            }
            #[doc = "8-Bit Host-Bus (HB8)"]
            #[inline]
            pub fn hb8(self) -> &'a mut W {
                self.variant(MODEW::HB8)
            }
            #[doc = "16-Bit Host-Bus (HB16)"]
            #[inline]
            pub fn hb16(self) -> &'a mut W {
                self.variant(MODEW::HB16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BLKENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BLKENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTDIVW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Mode Select"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 4 - Block Enable"]
            #[inline]
            pub fn blken(&self) -> BLKENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BLKENR { bits }
            }
            #[doc = "Bit 8 - Integer Clock Divider Enable"]
            #[inline]
            pub fn intdiv(&self) -> INTDIVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTDIVR { bits }
            }
        }
        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 0:3 - Mode Select"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 4 - Block Enable"]
            #[inline]
            pub fn blken(&mut self) -> _BLKENW {
                _BLKENW { w: self }
            }
            #[doc = "Bit 8 - Integer Clock Divider Enable"]
            #[inline]
            pub fn intdiv(&mut self) -> _INTDIVW {
                _INTDIVW { w: self }
            }
        }
    }
    #[doc = "EPI Main Baud Rate"]
    pub struct BAUD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Main Baud Rate"]
    pub mod baud {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::BAUD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNT0R {
            bits: u16,
        }
        impl COUNT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNT1R {
            bits: u16,
        }
        impl COUNT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNT0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNT1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Baud Rate Counter 0"]
            #[inline]
            pub fn count0(&self) -> COUNT0R {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNT0R { bits }
            }
            #[doc = "Bits 16:31 - Baud Rate Counter 1"]
            #[inline]
            pub fn count1(&self) -> COUNT1R {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNT1R { bits }
            }
        }
        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 0:15 - Baud Rate Counter 0"]
            #[inline]
            pub fn count0(&mut self) -> _COUNT0W {
                _COUNT0W { w: self }
            }
            #[doc = "Bits 16:31 - Baud Rate Counter 1"]
            #[inline]
            pub fn count1(&mut self) -> _COUNT1W {
                _COUNT1W { w: self }
            }
        }
    }
    #[doc = "EPI Main Baud Rate"]
    pub struct BAUD2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Main Baud Rate"]
    pub mod baud2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::BAUD2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNT0R {
            bits: u16,
        }
        impl COUNT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNT1R {
            bits: u16,
        }
        impl COUNT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNT0W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COUNT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _COUNT1W<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - CS2n Baud Rate Counter 0"]
            #[inline]
            pub fn count0(&self) -> COUNT0R {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNT0R { bits }
            }
            #[doc = "Bits 16:31 - CS3n Baud Rate Counter 1"]
            #[inline]
            pub fn count1(&self) -> COUNT1R {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                COUNT1R { bits }
            }
        }
        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 0:15 - CS2n Baud Rate Counter 0"]
            #[inline]
            pub fn count0(&mut self) -> _COUNT0W {
                _COUNT0W { w: self }
            }
            #[doc = "Bits 16:31 - CS3n Baud Rate Counter 1"]
            #[inline]
            pub fn count1(&mut self) -> _COUNT1W {
                _COUNT1W { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Configuration"]
    pub struct HB16CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Configuration"]
    pub mod hb16cfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16CFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            ADNMUX,
            #[doc = "Continuous Read - D[15:0]"]
            SRAM,
            #[doc = "XFIFO - D[15:0]"]
            XFIFO,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::ADNMUX => 0x01,
                    MODER::SRAM => 0x02,
                    MODER::XFIFO => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::ADNMUX,
                    2 => MODER::SRAM,
                    3 => MODER::XFIFO,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `ADNMUX`"]
            #[inline]
            pub fn is_adnmux(&self) -> bool {
                *self == MODER::ADNMUX
            }
            #[doc = "Checks if the value of the field is `SRAM`"]
            #[inline]
            pub fn is_sram(&self) -> bool {
                *self == MODER::SRAM
            }
            #[doc = "Checks if the value of the field is `XFIFO`"]
            #[inline]
            pub fn is_xfifo(&self) -> bool {
                *self == MODER::XFIFO
            }
        }
        #[doc = r" Value of the field"]
        pub struct BSELR {
            bits: bool,
        }
        impl BSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXWAITR {
            bits: u8,
        }
        impl MAXWAITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct BURSTR {
            bits: bool,
        }
        impl BURSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDCRER {
            bits: bool,
        }
        impl RDCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCRER {
            bits: bool,
        }
        impl WRCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFEENR {
            bits: bool,
        }
        impl XFEENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFFENR {
            bits: bool,
        }
        impl XFFENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYINVR {
            bits: bool,
        }
        impl IRDYINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDYENR {
            bits: bool,
        }
        impl RDYENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKINVR {
            bits: bool,
        }
        impl CLKINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKGATEIR {
            bits: bool,
        }
        impl CLKGATEIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKGATER {
            bits: bool,
        }
        impl CLKGATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            ADNMUX,
            #[doc = "Continuous Read - D[15:0]"]
            SRAM,
            #[doc = "XFIFO - D[15:0]"]
            XFIFO,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::ADNMUX => 1,
                    MODEW::SRAM => 2,
                    MODEW::XFIFO => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "ADMUX - AD[15:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[15:0]"]
            #[inline]
            pub fn adnmux(self) -> &'a mut W {
                self.variant(MODEW::ADNMUX)
            }
            #[doc = "Continuous Read - D[15:0]"]
            #[inline]
            pub fn sram(self) -> &'a mut W {
                self.variant(MODEW::SRAM)
            }
            #[doc = "XFIFO - D[15:0]"]
            #[inline]
            pub fn xfifo(self) -> &'a mut W {
                self.variant(MODEW::XFIFO)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BSELW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXWAITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXWAITW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                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 _BURSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BURSTW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDCREW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCREW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XFEENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XFEENW<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XFFENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XFFENW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYINVW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDYENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDYENW<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKINVW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKGATEIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKGATEIW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKGATEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKGATEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - Byte Select Configuration"]
            #[inline]
            pub fn bsel(&self) -> BSELR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BSELR { bits }
            }
            #[doc = "Bits 4:5 - Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:15 - Maximum Wait"]
            #[inline]
            pub fn maxwait(&self) -> MAXWAITR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MAXWAITR { bits }
            }
            #[doc = "Bit 16 - Burst Mode"]
            #[inline]
            pub fn burst(&self) -> BURSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BURSTR { bits }
            }
            #[doc = "Bit 17 - PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&self) -> RDCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDCRER { bits }
            }
            #[doc = "Bit 18 - PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&self) -> WRCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCRER { bits }
            }
            #[doc = "Bit 19 - ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
            #[doc = "Bit 22 - External FIFO EMPTY Enable"]
            #[inline]
            pub fn xfeen(&self) -> XFEENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFEENR { bits }
            }
            #[doc = "Bit 23 - External FIFO FULL Enable"]
            #[inline]
            pub fn xffen(&self) -> XFFENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFFENR { bits }
            }
            #[doc = "Bit 27 - Input Ready Invert"]
            #[inline]
            pub fn irdyinv(&self) -> IRDYINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IRDYINVR { bits }
            }
            #[doc = "Bit 28 - Input Ready Enable"]
            #[inline]
            pub fn rdyen(&self) -> RDYENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDYENR { bits }
            }
            #[doc = "Bit 29 - Invert Output Clock Enable"]
            #[inline]
            pub fn clkinv(&self) -> CLKINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKINVR { bits }
            }
            #[doc = "Bit 30 - Clock Gated Idle"]
            #[inline]
            pub fn clkgatei(&self) -> CLKGATEIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKGATEIR { bits }
            }
            #[doc = "Bit 31 - Clock Gated"]
            #[inline]
            pub fn clkgate(&self) -> CLKGATER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKGATER { bits }
            }
        }
        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 0:1 - Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bit 2 - Byte Select Configuration"]
            #[inline]
            pub fn bsel(&mut self) -> _BSELW {
                _BSELW { w: self }
            }
            #[doc = "Bits 4:5 - Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bits 8:15 - Maximum Wait"]
            #[inline]
            pub fn maxwait(&mut self) -> _MAXWAITW {
                _MAXWAITW { w: self }
            }
            #[doc = "Bit 16 - Burst Mode"]
            #[inline]
            pub fn burst(&mut self) -> _BURSTW {
                _BURSTW { w: self }
            }
            #[doc = "Bit 17 - PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&mut self) -> _RDCREW {
                _RDCREW { w: self }
            }
            #[doc = "Bit 18 - PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&mut self) -> _WRCREW {
                _WRCREW { w: self }
            }
            #[doc = "Bit 19 - ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
            #[doc = "Bit 22 - External FIFO EMPTY Enable"]
            #[inline]
            pub fn xfeen(&mut self) -> _XFEENW {
                _XFEENW { w: self }
            }
            #[doc = "Bit 23 - External FIFO FULL Enable"]
            #[inline]
            pub fn xffen(&mut self) -> _XFFENW {
                _XFFENW { w: self }
            }
            #[doc = "Bit 27 - Input Ready Invert"]
            #[inline]
            pub fn irdyinv(&mut self) -> _IRDYINVW {
                _IRDYINVW { w: self }
            }
            #[doc = "Bit 28 - Input Ready Enable"]
            #[inline]
            pub fn rdyen(&mut self) -> _RDYENW {
                _RDYENW { w: self }
            }
            #[doc = "Bit 29 - Invert Output Clock Enable"]
            #[inline]
            pub fn clkinv(&mut self) -> _CLKINVW {
                _CLKINVW { w: self }
            }
            #[doc = "Bit 30 - Clock Gated Idle"]
            #[inline]
            pub fn clkgatei(&mut self) -> _CLKGATEIW {
                _CLKGATEIW { w: self }
            }
            #[doc = "Bit 31 - Clock Gated"]
            #[inline]
            pub fn clkgate(&mut self) -> _CLKGATEW {
                _CLKGATEW { w: self }
            }
        }
    }
    #[doc = "EPI General-Purpose Configuration"]
    pub struct GPCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI General-Purpose Configuration"]
    pub mod gpcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::GPCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `DSIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DSIZER {
            #[doc = "8 Bits Wide (EPI0S0 to EPI0S7)"]
            _4BIT,
            #[doc = "16 Bits Wide (EPI0S0 to EPI0S15)"]
            _16BIT,
            #[doc = "24 Bits Wide (EPI0S0 to EPI0S23)"]
            _24BIT,
            #[doc = "32 Bits Wide (EPI0S0 to EPI0S31)"]
            _32BIT,
        }
        impl DSIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DSIZER::_4BIT => 0,
                    DSIZER::_16BIT => 0x01,
                    DSIZER::_24BIT => 0x02,
                    DSIZER::_32BIT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DSIZER {
                match value {
                    0 => DSIZER::_4BIT,
                    1 => DSIZER::_16BIT,
                    2 => DSIZER::_24BIT,
                    3 => DSIZER::_32BIT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_4BIT`"]
            #[inline]
            pub fn is_4bit(&self) -> bool {
                *self == DSIZER::_4BIT
            }
            #[doc = "Checks if the value of the field is `_16BIT`"]
            #[inline]
            pub fn is_16bit(&self) -> bool {
                *self == DSIZER::_16BIT
            }
            #[doc = "Checks if the value of the field is `_24BIT`"]
            #[inline]
            pub fn is_24bit(&self) -> bool {
                *self == DSIZER::_24BIT
            }
            #[doc = "Checks if the value of the field is `_32BIT`"]
            #[inline]
            pub fn is_32bit(&self) -> bool {
                *self == DSIZER::_32BIT
            }
        }
        #[doc = "Possible values of the field `ASIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ASIZER {
            #[doc = "No address"]
            NONE,
            #[doc = "Up to 4 bits wide"]
            _4BIT,
            #[doc = "Up to 12 bits wide. This size cannot be used with 24-bit data"]
            _12BIT,
            #[doc = "Up to 20 bits wide. This size cannot be used with data sizes other than 8"]
            _20BIT,
        }
        impl ASIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ASIZER::NONE => 0,
                    ASIZER::_4BIT => 0x01,
                    ASIZER::_12BIT => 0x02,
                    ASIZER::_20BIT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ASIZER {
                match value {
                    0 => ASIZER::NONE,
                    1 => ASIZER::_4BIT,
                    2 => ASIZER::_12BIT,
                    3 => ASIZER::_20BIT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ASIZER::NONE
            }
            #[doc = "Checks if the value of the field is `_4BIT`"]
            #[inline]
            pub fn is_4bit(&self) -> bool {
                *self == ASIZER::_4BIT
            }
            #[doc = "Checks if the value of the field is `_12BIT`"]
            #[inline]
            pub fn is_12bit(&self) -> bool {
                *self == ASIZER::_12BIT
            }
            #[doc = "Checks if the value of the field is `_20BIT`"]
            #[inline]
            pub fn is_20bit(&self) -> bool {
                *self == ASIZER::_20BIT
            }
        }
        #[doc = r" Value of the field"]
        pub struct WR2CYCR {
            bits: bool,
        }
        impl WR2CYCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FRMCNTR {
            bits: u8,
        }
        impl FRMCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FRM50R {
            bits: bool,
        }
        impl FRM50R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKGATER {
            bits: bool,
        }
        impl CLKGATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKPINR {
            bits: bool,
        }
        impl CLKPINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `DSIZE`"]
        pub enum DSIZEW {
            #[doc = "8 Bits Wide (EPI0S0 to EPI0S7)"]
            _4BIT,
            #[doc = "16 Bits Wide (EPI0S0 to EPI0S15)"]
            _16BIT,
            #[doc = "24 Bits Wide (EPI0S0 to EPI0S23)"]
            _24BIT,
            #[doc = "32 Bits Wide (EPI0S0 to EPI0S31)"]
            _32BIT,
        }
        impl DSIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DSIZEW::_4BIT => 0,
                    DSIZEW::_16BIT => 1,
                    DSIZEW::_24BIT => 2,
                    DSIZEW::_32BIT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DSIZEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "8 Bits Wide (EPI0S0 to EPI0S7)"]
            #[inline]
            pub fn _4bit(self) -> &'a mut W {
                self.variant(DSIZEW::_4BIT)
            }
            #[doc = "16 Bits Wide (EPI0S0 to EPI0S15)"]
            #[inline]
            pub fn _16bit(self) -> &'a mut W {
                self.variant(DSIZEW::_16BIT)
            }
            #[doc = "24 Bits Wide (EPI0S0 to EPI0S23)"]
            #[inline]
            pub fn _24bit(self) -> &'a mut W {
                self.variant(DSIZEW::_24BIT)
            }
            #[doc = "32 Bits Wide (EPI0S0 to EPI0S31)"]
            #[inline]
            pub fn _32bit(self) -> &'a mut W {
                self.variant(DSIZEW::_32BIT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ASIZE`"]
        pub enum ASIZEW {
            #[doc = "No address"]
            NONE,
            #[doc = "Up to 4 bits wide"]
            _4BIT,
            #[doc = "Up to 12 bits wide. This size cannot be used with 24-bit data"]
            _12BIT,
            #[doc = "Up to 20 bits wide. This size cannot be used with data sizes other than 8"]
            _20BIT,
        }
        impl ASIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ASIZEW::NONE => 0,
                    ASIZEW::_4BIT => 1,
                    ASIZEW::_12BIT => 2,
                    ASIZEW::_20BIT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ASIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ASIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ASIZEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No address"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ASIZEW::NONE)
            }
            #[doc = "Up to 4 bits wide"]
            #[inline]
            pub fn _4bit(self) -> &'a mut W {
                self.variant(ASIZEW::_4BIT)
            }
            #[doc = "Up to 12 bits wide. This size cannot be used with 24-bit data"]
            #[inline]
            pub fn _12bit(self) -> &'a mut W {
                self.variant(ASIZEW::_12BIT)
            }
            #[doc = "Up to 20 bits wide. This size cannot be used with data sizes other than 8"]
            #[inline]
            pub fn _20bit(self) -> &'a mut W {
                self.variant(ASIZEW::_20BIT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WR2CYCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WR2CYCW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FRMCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FRMCNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FRM50W<'a> {
            w: &'a mut W,
        }
        impl<'a> _FRM50W<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKGATEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKGATEW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKPINW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKPINW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Size of Data Bus"]
            #[inline]
            pub fn dsize(&self) -> DSIZER {
                DSIZER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Address Bus Size"]
            #[inline]
            pub fn asize(&self) -> ASIZER {
                ASIZER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 19 - 2-Cycle Writes"]
            #[inline]
            pub fn wr2cyc(&self) -> WR2CYCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WR2CYCR { bits }
            }
            #[doc = "Bits 22:25 - Frame Count"]
            #[inline]
            pub fn frmcnt(&self) -> FRMCNTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FRMCNTR { bits }
            }
            #[doc = "Bit 26 - 50/50 Frame"]
            #[inline]
            pub fn frm50(&self) -> FRM50R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FRM50R { bits }
            }
            #[doc = "Bit 30 - Clock Gated"]
            #[inline]
            pub fn clkgate(&self) -> CLKGATER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKGATER { bits }
            }
            #[doc = "Bit 31 - Clock Pin"]
            #[inline]
            pub fn clkpin(&self) -> CLKPINR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKPINR { bits }
            }
        }
        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 0:1 - Size of Data Bus"]
            #[inline]
            pub fn dsize(&mut self) -> _DSIZEW {
                _DSIZEW { w: self }
            }
            #[doc = "Bits 4:5 - Address Bus Size"]
            #[inline]
            pub fn asize(&mut self) -> _ASIZEW {
                _ASIZEW { w: self }
            }
            #[doc = "Bit 19 - 2-Cycle Writes"]
            #[inline]
            pub fn wr2cyc(&mut self) -> _WR2CYCW {
                _WR2CYCW { w: self }
            }
            #[doc = "Bits 22:25 - Frame Count"]
            #[inline]
            pub fn frmcnt(&mut self) -> _FRMCNTW {
                _FRMCNTW { w: self }
            }
            #[doc = "Bit 26 - 50/50 Frame"]
            #[inline]
            pub fn frm50(&mut self) -> _FRM50W {
                _FRM50W { w: self }
            }
            #[doc = "Bit 30 - Clock Gated"]
            #[inline]
            pub fn clkgate(&mut self) -> _CLKGATEW {
                _CLKGATEW { w: self }
            }
            #[doc = "Bit 31 - Clock Pin"]
            #[inline]
            pub fn clkpin(&mut self) -> _CLKPINW {
                _CLKPINW { w: self }
            }
        }
    }
    #[doc = "EPI SDRAM Configuration"]
    pub struct SDRAMCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI SDRAM Configuration"]
    pub mod sdramcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SDRAMCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "64 megabits (8MB)"]
            _8MB,
            #[doc = "128 megabits (16MB)"]
            _16MB,
            #[doc = "256 megabits (32MB)"]
            _32MB,
            #[doc = "512 megabits (64MB)"]
            _64MB,
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_8MB => 0,
                    SIZER::_16MB => 0x01,
                    SIZER::_32MB => 0x02,
                    SIZER::_64MB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    0 => SIZER::_8MB,
                    1 => SIZER::_16MB,
                    2 => SIZER::_32MB,
                    3 => SIZER::_64MB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_8MB`"]
            #[inline]
            pub fn is_8mb(&self) -> bool {
                *self == SIZER::_8MB
            }
            #[doc = "Checks if the value of the field is `_16MB`"]
            #[inline]
            pub fn is_16mb(&self) -> bool {
                *self == SIZER::_16MB
            }
            #[doc = "Checks if the value of the field is `_32MB`"]
            #[inline]
            pub fn is_32mb(&self) -> bool {
                *self == SIZER::_32MB
            }
            #[doc = "Checks if the value of the field is `_64MB`"]
            #[inline]
            pub fn is_64mb(&self) -> bool {
                *self == SIZER::_64MB
            }
        }
        #[doc = r" Value of the field"]
        pub struct SLEEPR {
            bits: bool,
        }
        impl SLEEPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RFSHR {
            bits: u16,
        }
        impl RFSHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `FREQ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum FREQR {
            #[doc = "0 - 15 MHz"]
            NONE,
            #[doc = "15 - 30 MHz"]
            _15MHZ,
            #[doc = "30 - 50 MHz"]
            _30MHZ,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl FREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    FREQR::NONE => 0,
                    FREQR::_15MHZ => 0x01,
                    FREQR::_30MHZ => 0x02,
                    FREQR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> FREQR {
                match value {
                    0 => FREQR::NONE,
                    1 => FREQR::_15MHZ,
                    2 => FREQR::_30MHZ,
                    i => FREQR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == FREQR::NONE
            }
            #[doc = "Checks if the value of the field is `_15MHZ`"]
            #[inline]
            pub fn is_15mhz(&self) -> bool {
                *self == FREQR::_15MHZ
            }
            #[doc = "Checks if the value of the field is `_30MHZ`"]
            #[inline]
            pub fn is_30mhz(&self) -> bool {
                *self == FREQR::_30MHZ
            }
        }
        #[doc = "Values that can be written to the field `SIZE`"]
        pub enum SIZEW {
            #[doc = "64 megabits (8MB)"]
            _8MB,
            #[doc = "128 megabits (16MB)"]
            _16MB,
            #[doc = "256 megabits (32MB)"]
            _32MB,
            #[doc = "512 megabits (64MB)"]
            _64MB,
        }
        impl SIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SIZEW::_8MB => 0,
                    SIZEW::_16MB => 1,
                    SIZEW::_32MB => 2,
                    SIZEW::_64MB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SIZEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "64 megabits (8MB)"]
            #[inline]
            pub fn _8mb(self) -> &'a mut W {
                self.variant(SIZEW::_8MB)
            }
            #[doc = "128 megabits (16MB)"]
            #[inline]
            pub fn _16mb(self) -> &'a mut W {
                self.variant(SIZEW::_16MB)
            }
            #[doc = "256 megabits (32MB)"]
            #[inline]
            pub fn _32mb(self) -> &'a mut W {
                self.variant(SIZEW::_32MB)
            }
            #[doc = "512 megabits (64MB)"]
            #[inline]
            pub fn _64mb(self) -> &'a mut W {
                self.variant(SIZEW::_64MB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SLEEPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SLEEPW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RFSHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RFSHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x07ff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `FREQ`"]
        pub enum FREQW {
            #[doc = "0 - 15 MHz"]
            NONE,
            #[doc = "15 - 30 MHz"]
            _15MHZ,
            #[doc = "30 - 50 MHz"]
            _30MHZ,
        }
        impl FREQW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    FREQW::NONE => 0,
                    FREQW::_15MHZ => 1,
                    FREQW::_30MHZ => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _FREQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FREQW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: FREQW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "0 - 15 MHz"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(FREQW::NONE)
            }
            #[doc = "15 - 30 MHz"]
            #[inline]
            pub fn _15mhz(self) -> &'a mut W {
                self.variant(FREQW::_15MHZ)
            }
            #[doc = "30 - 50 MHz"]
            #[inline]
            pub fn _30mhz(self) -> &'a mut W {
                self.variant(FREQW::_30MHZ)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Size of SDRAM"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 9 - Sleep Mode"]
            #[inline]
            pub fn sleep(&self) -> SLEEPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SLEEPR { bits }
            }
            #[doc = "Bits 16:26 - Refresh Counter"]
            #[inline]
            pub fn rfsh(&self) -> RFSHR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RFSHR { bits }
            }
            #[doc = "Bits 30:31 - EPI Frequency Range"]
            #[inline]
            pub fn freq(&self) -> FREQR {
                FREQR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Size of SDRAM"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
            #[doc = "Bit 9 - Sleep Mode"]
            #[inline]
            pub fn sleep(&mut self) -> _SLEEPW {
                _SLEEPW { w: self }
            }
            #[doc = "Bits 16:26 - Refresh Counter"]
            #[inline]
            pub fn rfsh(&mut self) -> _RFSHW {
                _RFSHW { w: self }
            }
            #[doc = "Bits 30:31 - EPI Frequency Range"]
            #[inline]
            pub fn freq(&mut self) -> _FREQW {
                _FREQW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Configuration"]
    pub struct HB8CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Configuration"]
    pub mod hb8cfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8CFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[7:0]"]
            MUX,
            #[doc = "ADNONMUX - D[7:0]"]
            NMUX,
            #[doc = "Continuous Read - D[7:0]"]
            SRAM,
            #[doc = "XFIFO - D[7:0]"]
            FIFO,
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::MUX => 0,
                    MODER::NMUX => 0x01,
                    MODER::SRAM => 0x02,
                    MODER::FIFO => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::MUX,
                    1 => MODER::NMUX,
                    2 => MODER::SRAM,
                    3 => MODER::FIFO,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `MUX`"]
            #[inline]
            pub fn is_mux(&self) -> bool {
                *self == MODER::MUX
            }
            #[doc = "Checks if the value of the field is `NMUX`"]
            #[inline]
            pub fn is_nmux(&self) -> bool {
                *self == MODER::NMUX
            }
            #[doc = "Checks if the value of the field is `SRAM`"]
            #[inline]
            pub fn is_sram(&self) -> bool {
                *self == MODER::SRAM
            }
            #[doc = "Checks if the value of the field is `FIFO`"]
            #[inline]
            pub fn is_fifo(&self) -> bool {
                *self == MODER::FIFO
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct MAXWAITR {
            bits: u8,
        }
        impl MAXWAITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFEENR {
            bits: bool,
        }
        impl XFEENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFFENR {
            bits: bool,
        }
        impl XFFENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYINVR {
            bits: bool,
        }
        impl IRDYINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDYENR {
            bits: bool,
        }
        impl RDYENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKINVR {
            bits: bool,
        }
        impl CLKINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKGATEIR {
            bits: bool,
        }
        impl CLKGATEIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLKGATER {
            bits: bool,
        }
        impl CLKGATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[7:0]"]
            MUX,
            #[doc = "ADNONMUX - D[7:0]"]
            NMUX,
            #[doc = "Continuous Read - D[7:0]"]
            SRAM,
            #[doc = "XFIFO - D[7:0]"]
            FIFO,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::MUX => 0,
                    MODEW::NMUX => 1,
                    MODEW::SRAM => 2,
                    MODEW::FIFO => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "ADMUX - AD[7:0]"]
            #[inline]
            pub fn mux(self) -> &'a mut W {
                self.variant(MODEW::MUX)
            }
            #[doc = "ADNONMUX - D[7:0]"]
            #[inline]
            pub fn nmux(self) -> &'a mut W {
                self.variant(MODEW::NMUX)
            }
            #[doc = "Continuous Read - D[7:0]"]
            #[inline]
            pub fn sram(self) -> &'a mut W {
                self.variant(MODEW::SRAM)
            }
            #[doc = "XFIFO - D[7:0]"]
            #[inline]
            pub fn fifo(self) -> &'a mut W {
                self.variant(MODEW::FIFO)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MAXWAITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MAXWAITW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                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 _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XFEENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XFEENW<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _XFFENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XFFENW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYINVW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDYENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDYENW<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKINVW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKGATEIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKGATEIW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLKGATEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLKGATEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:15 - Maximum Wait"]
            #[inline]
            pub fn maxwait(&self) -> MAXWAITR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MAXWAITR { bits }
            }
            #[doc = "Bit 19 - ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
            #[doc = "Bit 22 - External FIFO EMPTY Enable"]
            #[inline]
            pub fn xfeen(&self) -> XFEENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFEENR { bits }
            }
            #[doc = "Bit 23 - External FIFO FULL Enable"]
            #[inline]
            pub fn xffen(&self) -> XFFENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFFENR { bits }
            }
            #[doc = "Bit 27 - Input Ready Invert"]
            #[inline]
            pub fn irdyinv(&self) -> IRDYINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IRDYINVR { bits }
            }
            #[doc = "Bit 28 - Input Ready Enable"]
            #[inline]
            pub fn rdyen(&self) -> RDYENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDYENR { bits }
            }
            #[doc = "Bit 29 - Invert Output Clock Enable"]
            #[inline]
            pub fn clkinv(&self) -> CLKINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKINVR { bits }
            }
            #[doc = "Bit 30 - Clock Gated when Idle"]
            #[inline]
            pub fn clkgatei(&self) -> CLKGATEIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKGATEIR { bits }
            }
            #[doc = "Bit 31 - Clock Gated"]
            #[inline]
            pub fn clkgate(&self) -> CLKGATER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLKGATER { bits }
            }
        }
        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 0:1 - Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bits 8:15 - Maximum Wait"]
            #[inline]
            pub fn maxwait(&mut self) -> _MAXWAITW {
                _MAXWAITW { w: self }
            }
            #[doc = "Bit 19 - ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
            #[doc = "Bit 22 - External FIFO EMPTY Enable"]
            #[inline]
            pub fn xfeen(&mut self) -> _XFEENW {
                _XFEENW { w: self }
            }
            #[doc = "Bit 23 - External FIFO FULL Enable"]
            #[inline]
            pub fn xffen(&mut self) -> _XFFENW {
                _XFFENW { w: self }
            }
            #[doc = "Bit 27 - Input Ready Invert"]
            #[inline]
            pub fn irdyinv(&mut self) -> _IRDYINVW {
                _IRDYINVW { w: self }
            }
            #[doc = "Bit 28 - Input Ready Enable"]
            #[inline]
            pub fn rdyen(&mut self) -> _RDYENW {
                _RDYENW { w: self }
            }
            #[doc = "Bit 29 - Invert Output Clock Enable"]
            #[inline]
            pub fn clkinv(&mut self) -> _CLKINVW {
                _CLKINVW { w: self }
            }
            #[doc = "Bit 30 - Clock Gated when Idle"]
            #[inline]
            pub fn clkgatei(&mut self) -> _CLKGATEIW {
                _CLKGATEIW { w: self }
            }
            #[doc = "Bit 31 - Clock Gated"]
            #[inline]
            pub fn clkgate(&mut self) -> _CLKGATEW {
                _CLKGATEW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Configuration 2"]
    pub struct HB8CFG2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Configuration 2"]
    pub mod hb8cfg2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8CFG2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CSCFG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CSCFGR {
            #[doc = "ALE Configuration"]
            ALE,
            #[doc = "CSn Configuration"]
            CS,
            #[doc = "Dual CSn Configuration"]
            DCS,
            #[doc = "ALE with Dual CSn Configuration"]
            ADCS,
        }
        impl CSCFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CSCFGR::ALE => 0,
                    CSCFGR::CS => 0x01,
                    CSCFGR::DCS => 0x02,
                    CSCFGR::ADCS => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CSCFGR {
                match value {
                    0 => CSCFGR::ALE,
                    1 => CSCFGR::CS,
                    2 => CSCFGR::DCS,
                    3 => CSCFGR::ADCS,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALE`"]
            #[inline]
            pub fn is_ale(&self) -> bool {
                *self == CSCFGR::ALE
            }
            #[doc = "Checks if the value of the field is `CS`"]
            #[inline]
            pub fn is_cs(&self) -> bool {
                *self == CSCFGR::CS
            }
            #[doc = "Checks if the value of the field is `DCS`"]
            #[inline]
            pub fn is_dcs(&self) -> bool {
                *self == CSCFGR::DCS
            }
            #[doc = "Checks if the value of the field is `ADCS`"]
            #[inline]
            pub fn is_adcs(&self) -> bool {
                *self == CSCFGR::ADCS
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSBAUDR {
            bits: bool,
        }
        impl CSBAUDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSCFGEXTR {
            bits: bool,
        }
        impl CSCFGEXTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[7:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[7:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CSCFG`"]
        pub enum CSCFGW {
            #[doc = "ALE Configuration"]
            ALE,
            #[doc = "CSn Configuration"]
            CS,
            #[doc = "Dual CSn Configuration"]
            DCS,
            #[doc = "ALE with Dual CSn Configuration"]
            ADCS,
        }
        impl CSCFGW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CSCFGW::ALE => 0,
                    CSCFGW::CS => 1,
                    CSCFGW::DCS => 2,
                    CSCFGW::ADCS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSCFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSCFGW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CSCFGW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "ALE Configuration"]
            #[inline]
            pub fn ale(self) -> &'a mut W {
                self.variant(CSCFGW::ALE)
            }
            #[doc = "CSn Configuration"]
            #[inline]
            pub fn cs(self) -> &'a mut W {
                self.variant(CSCFGW::CS)
            }
            #[doc = "Dual CSn Configuration"]
            #[inline]
            pub fn dcs(self) -> &'a mut W {
                self.variant(CSCFGW::DCS)
            }
            #[doc = "ALE with Dual CSn Configuration"]
            #[inline]
            pub fn adcs(self) -> &'a mut W {
                self.variant(CSCFGW::ADCS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSBAUDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSBAUDW<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSCFGEXTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSCFGEXTW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS1n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS1n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS1n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 19 - CS1n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS1n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS1n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
            #[doc = "Bits 24:25 - Chip Select Configuration"]
            #[inline]
            pub fn cscfg(&self) -> CSCFGR {
                CSCFGR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 26 - Chip Select Baud Rate and Multiple Sub-Mode Configuration enable"]
            #[inline]
            pub fn csbaud(&self) -> CSBAUDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSBAUDR { bits }
            }
            #[doc = "Bit 27 - Chip Select Extended Configuration"]
            #[inline]
            pub fn cscfgext(&self) -> CSCFGEXTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSCFGEXTR { bits }
            }
        }
        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 0:1 - CS1n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS1n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS1n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 19 - CS1n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS1n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS1n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
            #[doc = "Bits 24:25 - Chip Select Configuration"]
            #[inline]
            pub fn cscfg(&mut self) -> _CSCFGW {
                _CSCFGW { w: self }
            }
            #[doc = "Bit 26 - Chip Select Baud Rate and Multiple Sub-Mode Configuration enable"]
            #[inline]
            pub fn csbaud(&mut self) -> _CSBAUDW {
                _CSBAUDW { w: self }
            }
            #[doc = "Bit 27 - Chip Select Extended Configuration"]
            #[inline]
            pub fn cscfgext(&mut self) -> _CSCFGEXTW {
                _CSCFGEXTW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Configuration 2"]
    pub struct HB16CFG2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Configuration 2"]
    pub mod hb16cfg2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16CFG2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct BURSTR {
            bits: bool,
        }
        impl BURSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDCRER {
            bits: bool,
        }
        impl RDCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCRER {
            bits: bool,
        }
        impl WRCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CSCFG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CSCFGR {
            #[doc = "ALE Configuration"]
            ALE,
            #[doc = "CSn Configuration"]
            CS,
            #[doc = "Dual CSn Configuration"]
            DCS,
            #[doc = "ALE with Dual CSn Configuration"]
            ADCS,
        }
        impl CSCFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CSCFGR::ALE => 0,
                    CSCFGR::CS => 0x01,
                    CSCFGR::DCS => 0x02,
                    CSCFGR::ADCS => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CSCFGR {
                match value {
                    0 => CSCFGR::ALE,
                    1 => CSCFGR::CS,
                    2 => CSCFGR::DCS,
                    3 => CSCFGR::ADCS,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALE`"]
            #[inline]
            pub fn is_ale(&self) -> bool {
                *self == CSCFGR::ALE
            }
            #[doc = "Checks if the value of the field is `CS`"]
            #[inline]
            pub fn is_cs(&self) -> bool {
                *self == CSCFGR::CS
            }
            #[doc = "Checks if the value of the field is `DCS`"]
            #[inline]
            pub fn is_dcs(&self) -> bool {
                *self == CSCFGR::DCS
            }
            #[doc = "Checks if the value of the field is `ADCS`"]
            #[inline]
            pub fn is_adcs(&self) -> bool {
                *self == CSCFGR::ADCS
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSBAUDR {
            bits: bool,
        }
        impl CSBAUDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSCFGEXTR {
            bits: bool,
        }
        impl CSCFGEXTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[15:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[15:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BURSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BURSTW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDCREW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCREW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CSCFG`"]
        pub enum CSCFGW {
            #[doc = "ALE Configuration"]
            ALE,
            #[doc = "CSn Configuration"]
            CS,
            #[doc = "Dual CSn Configuration"]
            DCS,
            #[doc = "ALE with Dual CSn Configuration"]
            ADCS,
        }
        impl CSCFGW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CSCFGW::ALE => 0,
                    CSCFGW::CS => 1,
                    CSCFGW::DCS => 2,
                    CSCFGW::ADCS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSCFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSCFGW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CSCFGW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "ALE Configuration"]
            #[inline]
            pub fn ale(self) -> &'a mut W {
                self.variant(CSCFGW::ALE)
            }
            #[doc = "CSn Configuration"]
            #[inline]
            pub fn cs(self) -> &'a mut W {
                self.variant(CSCFGW::CS)
            }
            #[doc = "Dual CSn Configuration"]
            #[inline]
            pub fn dcs(self) -> &'a mut W {
                self.variant(CSCFGW::DCS)
            }
            #[doc = "ALE with Dual CSn Configuration"]
            #[inline]
            pub fn adcs(self) -> &'a mut W {
                self.variant(CSCFGW::ADCS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSBAUDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSBAUDW<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSCFGEXTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSCFGEXTW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS1n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS1n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS1n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - CS1n Burst Mode"]
            #[inline]
            pub fn burst(&self) -> BURSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BURSTR { bits }
            }
            #[doc = "Bit 17 - CS1n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&self) -> RDCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDCRER { bits }
            }
            #[doc = "Bit 18 - CS1n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&self) -> WRCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCRER { bits }
            }
            #[doc = "Bit 19 - CS1n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS1n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS1n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
            #[doc = "Bits 24:25 - Chip Select Configuration"]
            #[inline]
            pub fn cscfg(&self) -> CSCFGR {
                CSCFGR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 26 - Chip Select Baud Rate and Multiple Sub-Mode Configuration enable"]
            #[inline]
            pub fn csbaud(&self) -> CSBAUDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSBAUDR { bits }
            }
            #[doc = "Bit 27 - Chip Select Extended Configuration"]
            #[inline]
            pub fn cscfgext(&self) -> CSCFGEXTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSCFGEXTR { bits }
            }
        }
        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 0:1 - CS1n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS1n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS1n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 16 - CS1n Burst Mode"]
            #[inline]
            pub fn burst(&mut self) -> _BURSTW {
                _BURSTW { w: self }
            }
            #[doc = "Bit 17 - CS1n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&mut self) -> _RDCREW {
                _RDCREW { w: self }
            }
            #[doc = "Bit 18 - CS1n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&mut self) -> _WRCREW {
                _WRCREW { w: self }
            }
            #[doc = "Bit 19 - CS1n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS1n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS1n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
            #[doc = "Bits 24:25 - Chip Select Configuration"]
            #[inline]
            pub fn cscfg(&mut self) -> _CSCFGW {
                _CSCFGW { w: self }
            }
            #[doc = "Bit 26 - Chip Select Baud Rate and Multiple Sub-Mode Configuration enable"]
            #[inline]
            pub fn csbaud(&mut self) -> _CSBAUDW {
                _CSBAUDW { w: self }
            }
            #[doc = "Bit 27 - Chip Select Extended Configuration"]
            #[inline]
            pub fn cscfgext(&mut self) -> _CSCFGEXTW {
                _CSCFGEXTW { w: self }
            }
        }
    }
    #[doc = "EPI Address Map"]
    pub struct ADDRMAP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Address Map"]
    pub mod addrmap {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDRMAP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ERADR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ERADRR {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0x6000.0000"]
            _6000,
            #[doc = "At 0x8000.0000"]
            _8000,
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS0n maps to 0x6000.0000 and CS1n maps to 0x8000.0000"]
            HBQS,
        }
        impl ERADRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ERADRR::NONE => 0,
                    ERADRR::_6000 => 0x01,
                    ERADRR::_8000 => 0x02,
                    ERADRR::HBQS => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ERADRR {
                match value {
                    0 => ERADRR::NONE,
                    1 => ERADRR::_6000,
                    2 => ERADRR::_8000,
                    3 => ERADRR::HBQS,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ERADRR::NONE
            }
            #[doc = "Checks if the value of the field is `_6000`"]
            #[inline]
            pub fn is_6000(&self) -> bool {
                *self == ERADRR::_6000
            }
            #[doc = "Checks if the value of the field is `_8000`"]
            #[inline]
            pub fn is_8000(&self) -> bool {
                *self == ERADRR::_8000
            }
            #[doc = "Checks if the value of the field is `HBQS`"]
            #[inline]
            pub fn is_hbqs(&self) -> bool {
                *self == ERADRR::HBQS
            }
        }
        #[doc = "Possible values of the field `ERSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ERSZR {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            _256MB,
        }
        impl ERSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ERSZR::_256B => 0,
                    ERSZR::_64KB => 0x01,
                    ERSZR::_16MB => 0x02,
                    ERSZR::_256MB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ERSZR {
                match value {
                    0 => ERSZR::_256B,
                    1 => ERSZR::_64KB,
                    2 => ERSZR::_16MB,
                    3 => ERSZR::_256MB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == ERSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_64KB`"]
            #[inline]
            pub fn is_64kb(&self) -> bool {
                *self == ERSZR::_64KB
            }
            #[doc = "Checks if the value of the field is `_16MB`"]
            #[inline]
            pub fn is_16mb(&self) -> bool {
                *self == ERSZR::_16MB
            }
            #[doc = "Checks if the value of the field is `_256MB`"]
            #[inline]
            pub fn is_256mb(&self) -> bool {
                *self == ERSZR::_256MB
            }
        }
        #[doc = "Possible values of the field `EPADR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EPADRR {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0xA000.0000"]
            A000,
            #[doc = "At 0xC000.0000"]
            C000,
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS2n maps to 0xA000.0000 and CS3n maps to 0xC000.0000"]
            HBQS,
        }
        impl EPADRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EPADRR::NONE => 0,
                    EPADRR::A000 => 0x01,
                    EPADRR::C000 => 0x02,
                    EPADRR::HBQS => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EPADRR {
                match value {
                    0 => EPADRR::NONE,
                    1 => EPADRR::A000,
                    2 => EPADRR::C000,
                    3 => EPADRR::HBQS,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == EPADRR::NONE
            }
            #[doc = "Checks if the value of the field is `A000`"]
            #[inline]
            pub fn is_a000(&self) -> bool {
                *self == EPADRR::A000
            }
            #[doc = "Checks if the value of the field is `C000`"]
            #[inline]
            pub fn is_c000(&self) -> bool {
                *self == EPADRR::C000
            }
            #[doc = "Checks if the value of the field is `HBQS`"]
            #[inline]
            pub fn is_hbqs(&self) -> bool {
                *self == EPADRR::HBQS
            }
        }
        #[doc = "Possible values of the field `EPSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EPSZR {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            _256MB,
        }
        impl EPSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EPSZR::_256B => 0,
                    EPSZR::_64KB => 0x01,
                    EPSZR::_16MB => 0x02,
                    EPSZR::_256MB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EPSZR {
                match value {
                    0 => EPSZR::_256B,
                    1 => EPSZR::_64KB,
                    2 => EPSZR::_16MB,
                    3 => EPSZR::_256MB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == EPSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_64KB`"]
            #[inline]
            pub fn is_64kb(&self) -> bool {
                *self == EPSZR::_64KB
            }
            #[doc = "Checks if the value of the field is `_16MB`"]
            #[inline]
            pub fn is_16mb(&self) -> bool {
                *self == EPSZR::_16MB
            }
            #[doc = "Checks if the value of the field is `_256MB`"]
            #[inline]
            pub fn is_256mb(&self) -> bool {
                *self == EPSZR::_256MB
            }
        }
        #[doc = "Possible values of the field `ECADR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ECADRR {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0x1000.0000"]
            _1000,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ECADRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ECADRR::NONE => 0,
                    ECADRR::_1000 => 0x01,
                    ECADRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ECADRR {
                match value {
                    0 => ECADRR::NONE,
                    1 => ECADRR::_1000,
                    i => ECADRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == ECADRR::NONE
            }
            #[doc = "Checks if the value of the field is `_1000`"]
            #[inline]
            pub fn is_1000(&self) -> bool {
                *self == ECADRR::_1000
            }
        }
        #[doc = "Possible values of the field `ECSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ECSZR {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256MB; lower address range: 0x000.0000 to 0x0FFF.FFFF"]
            _256MB,
        }
        impl ECSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ECSZR::_256B => 0,
                    ECSZR::_64KB => 0x01,
                    ECSZR::_16MB => 0x02,
                    ECSZR::_256MB => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ECSZR {
                match value {
                    0 => ECSZR::_256B,
                    1 => ECSZR::_64KB,
                    2 => ECSZR::_16MB,
                    3 => ECSZR::_256MB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == ECSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_64KB`"]
            #[inline]
            pub fn is_64kb(&self) -> bool {
                *self == ECSZR::_64KB
            }
            #[doc = "Checks if the value of the field is `_16MB`"]
            #[inline]
            pub fn is_16mb(&self) -> bool {
                *self == ECSZR::_16MB
            }
            #[doc = "Checks if the value of the field is `_256MB`"]
            #[inline]
            pub fn is_256mb(&self) -> bool {
                *self == ECSZR::_256MB
            }
        }
        #[doc = "Values that can be written to the field `ERADR`"]
        pub enum ERADRW {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0x6000.0000"]
            _6000,
            #[doc = "At 0x8000.0000"]
            _8000,
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS0n maps to 0x6000.0000 and CS1n maps to 0x8000.0000"]
            HBQS,
        }
        impl ERADRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ERADRW::NONE => 0,
                    ERADRW::_6000 => 1,
                    ERADRW::_8000 => 2,
                    ERADRW::HBQS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERADRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERADRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ERADRW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Not mapped"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ERADRW::NONE)
            }
            #[doc = "At 0x6000.0000"]
            #[inline]
            pub fn _6000(self) -> &'a mut W {
                self.variant(ERADRW::_6000)
            }
            #[doc = "At 0x8000.0000"]
            #[inline]
            pub fn _8000(self) -> &'a mut W {
                self.variant(ERADRW::_8000)
            }
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS0n maps to 0x6000.0000 and CS1n maps to 0x8000.0000"]
            #[inline]
            pub fn hbqs(self) -> &'a mut W {
                self.variant(ERADRW::HBQS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ERSZ`"]
        pub enum ERSZW {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            _256MB,
        }
        impl ERSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ERSZW::_256B => 0,
                    ERSZW::_64KB => 1,
                    ERSZW::_16MB => 2,
                    ERSZW::_256MB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ERSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(ERSZW::_256B)
            }
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            #[inline]
            pub fn _64kb(self) -> &'a mut W {
                self.variant(ERSZW::_64KB)
            }
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            #[inline]
            pub fn _16mb(self) -> &'a mut W {
                self.variant(ERSZW::_16MB)
            }
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            #[inline]
            pub fn _256mb(self) -> &'a mut W {
                self.variant(ERSZW::_256MB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EPADR`"]
        pub enum EPADRW {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0xA000.0000"]
            A000,
            #[doc = "At 0xC000.0000"]
            C000,
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS2n maps to 0xA000.0000 and CS3n maps to 0xC000.0000"]
            HBQS,
        }
        impl EPADRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EPADRW::NONE => 0,
                    EPADRW::A000 => 1,
                    EPADRW::C000 => 2,
                    EPADRW::HBQS => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPADRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPADRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EPADRW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Not mapped"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(EPADRW::NONE)
            }
            #[doc = "At 0xA000.0000"]
            #[inline]
            pub fn a000(self) -> &'a mut W {
                self.variant(EPADRW::A000)
            }
            #[doc = "At 0xC000.0000"]
            #[inline]
            pub fn c000(self) -> &'a mut W {
                self.variant(EPADRW::C000)
            }
            #[doc = "Only to be used with Host Bus quad chip select. In quad chip select mode, CS2n maps to 0xA000.0000 and CS3n maps to 0xC000.0000"]
            #[inline]
            pub fn hbqs(self) -> &'a mut W {
                self.variant(EPADRW::HBQS)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EPSZ`"]
        pub enum EPSZW {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            _256MB,
        }
        impl EPSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EPSZW::_256B => 0,
                    EPSZW::_64KB => 1,
                    EPSZW::_16MB => 2,
                    EPSZW::_256MB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EPSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EPSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EPSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(EPSZW::_256B)
            }
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            #[inline]
            pub fn _64kb(self) -> &'a mut W {
                self.variant(EPSZW::_64KB)
            }
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            #[inline]
            pub fn _16mb(self) -> &'a mut W {
                self.variant(EPSZW::_16MB)
            }
            #[doc = "256 MB; lower address range: 0x000.0000 to 0xFFF.FFFF"]
            #[inline]
            pub fn _256mb(self) -> &'a mut W {
                self.variant(EPSZW::_256MB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ECADR`"]
        pub enum ECADRW {
            #[doc = "Not mapped"]
            NONE,
            #[doc = "At 0x1000.0000"]
            _1000,
        }
        impl ECADRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ECADRW::NONE => 0,
                    ECADRW::_1000 => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ECADRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ECADRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ECADRW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Not mapped"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(ECADRW::NONE)
            }
            #[doc = "At 0x1000.0000"]
            #[inline]
            pub fn _1000(self) -> &'a mut W {
                self.variant(ECADRW::_1000)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ECSZ`"]
        pub enum ECSZW {
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            _256B,
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            _64KB,
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            _16MB,
            #[doc = "256MB; lower address range: 0x000.0000 to 0x0FFF.FFFF"]
            _256MB,
        }
        impl ECSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ECSZW::_256B => 0,
                    ECSZW::_64KB => 1,
                    ECSZW::_16MB => 2,
                    ECSZW::_256MB => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ECSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ECSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ECSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "256 bytes; lower address range: 0x00 to 0xFF"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(ECSZW::_256B)
            }
            #[doc = "64 KB; lower address range: 0x0000 to 0xFFFF"]
            #[inline]
            pub fn _64kb(self) -> &'a mut W {
                self.variant(ECSZW::_64KB)
            }
            #[doc = "16 MB; lower address range: 0x00.0000 to 0xFF.FFFF"]
            #[inline]
            pub fn _16mb(self) -> &'a mut W {
                self.variant(ECSZW::_16MB)
            }
            #[doc = "256MB; lower address range: 0x000.0000 to 0x0FFF.FFFF"]
            #[inline]
            pub fn _256mb(self) -> &'a mut W {
                self.variant(ECSZW::_256MB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - External RAM Address"]
            #[inline]
            pub fn eradr(&self) -> ERADRR {
                ERADRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - External RAM Size"]
            #[inline]
            pub fn ersz(&self) -> ERSZR {
                ERSZR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - External Peripheral Address"]
            #[inline]
            pub fn epadr(&self) -> EPADRR {
                EPADRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - External Peripheral Size"]
            #[inline]
            pub fn epsz(&self) -> EPSZR {
                EPSZR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - External Code Address"]
            #[inline]
            pub fn ecadr(&self) -> ECADRR {
                ECADRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - External Code Size"]
            #[inline]
            pub fn ecsz(&self) -> ECSZR {
                ECSZR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - External RAM Address"]
            #[inline]
            pub fn eradr(&mut self) -> _ERADRW {
                _ERADRW { w: self }
            }
            #[doc = "Bits 2:3 - External RAM Size"]
            #[inline]
            pub fn ersz(&mut self) -> _ERSZW {
                _ERSZW { w: self }
            }
            #[doc = "Bits 4:5 - External Peripheral Address"]
            #[inline]
            pub fn epadr(&mut self) -> _EPADRW {
                _EPADRW { w: self }
            }
            #[doc = "Bits 6:7 - External Peripheral Size"]
            #[inline]
            pub fn epsz(&mut self) -> _EPSZW {
                _EPSZW { w: self }
            }
            #[doc = "Bits 8:9 - External Code Address"]
            #[inline]
            pub fn ecadr(&mut self) -> _ECADRW {
                _ECADRW { w: self }
            }
            #[doc = "Bits 10:11 - External Code Size"]
            #[inline]
            pub fn ecsz(&mut self) -> _ECSZW {
                _ECSZW { w: self }
            }
        }
    }
    #[doc = "EPI Read Size 0"]
    pub struct RSIZE0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read Size 0"]
    pub mod rsize0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RSIZE0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "Byte (8 bits)"]
            _8BIT,
            #[doc = "Half-word (16 bits)"]
            _16BIT,
            #[doc = "Word (32 bits)"]
            _32BIT,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_8BIT => 0x01,
                    SIZER::_16BIT => 0x02,
                    SIZER::_32BIT => 0x03,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    1 => SIZER::_8BIT,
                    2 => SIZER::_16BIT,
                    3 => SIZER::_32BIT,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_8BIT`"]
            #[inline]
            pub fn is_8bit(&self) -> bool {
                *self == SIZER::_8BIT
            }
            #[doc = "Checks if the value of the field is `_16BIT`"]
            #[inline]
            pub fn is_16bit(&self) -> bool {
                *self == SIZER::_16BIT
            }
            #[doc = "Checks if the value of the field is `_32BIT`"]
            #[inline]
            pub fn is_32bit(&self) -> bool {
                *self == SIZER::_32BIT
            }
        }
        #[doc = "Values that can be written to the field `SIZE`"]
        pub enum SIZEW {
            #[doc = "Byte (8 bits)"]
            _8BIT,
            #[doc = "Half-word (16 bits)"]
            _16BIT,
            #[doc = "Word (32 bits)"]
            _32BIT,
        }
        impl SIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SIZEW::_8BIT => 1,
                    SIZEW::_16BIT => 2,
                    SIZEW::_32BIT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SIZEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Byte (8 bits)"]
            #[inline]
            pub fn _8bit(self) -> &'a mut W {
                self.variant(SIZEW::_8BIT)
            }
            #[doc = "Half-word (16 bits)"]
            #[inline]
            pub fn _16bit(self) -> &'a mut W {
                self.variant(SIZEW::_16BIT)
            }
            #[doc = "Word (32 bits)"]
            #[inline]
            pub fn _32bit(self) -> &'a mut W {
                self.variant(SIZEW::_32BIT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Current Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Current Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
        }
    }
    #[doc = "EPI Read Address 0"]
    pub struct RADDR0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read Address 0"]
    pub mod raddr0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RADDR0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Current Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 0:31 - Current Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "EPI Non-Blocking Read Data 0"]
    pub struct RPSTD0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Non-Blocking Read Data 0"]
    pub mod rpstd0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RPSTD0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct POSTCNTR {
            bits: u16,
        }
        impl POSTCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _POSTCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _POSTCNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Post Count"]
            #[inline]
            pub fn postcnt(&self) -> POSTCNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                POSTCNTR { bits }
            }
        }
        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 0:12 - Post Count"]
            #[inline]
            pub fn postcnt(&mut self) -> _POSTCNTW {
                _POSTCNTW { w: self }
            }
        }
    }
    #[doc = "EPI Read Size 1"]
    pub struct RSIZE1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read Size 1"]
    pub mod rsize1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RSIZE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "Byte (8 bits)"]
            _8BIT,
            #[doc = "Half-word (16 bits)"]
            _16BIT,
            #[doc = "Word (32 bits)"]
            _32BIT,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SIZER::_8BIT => 0x01,
                    SIZER::_16BIT => 0x02,
                    SIZER::_32BIT => 0x03,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SIZER {
                match value {
                    1 => SIZER::_8BIT,
                    2 => SIZER::_16BIT,
                    3 => SIZER::_32BIT,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_8BIT`"]
            #[inline]
            pub fn is_8bit(&self) -> bool {
                *self == SIZER::_8BIT
            }
            #[doc = "Checks if the value of the field is `_16BIT`"]
            #[inline]
            pub fn is_16bit(&self) -> bool {
                *self == SIZER::_16BIT
            }
            #[doc = "Checks if the value of the field is `_32BIT`"]
            #[inline]
            pub fn is_32bit(&self) -> bool {
                *self == SIZER::_32BIT
            }
        }
        #[doc = "Values that can be written to the field `SIZE`"]
        pub enum SIZEW {
            #[doc = "Byte (8 bits)"]
            _8BIT,
            #[doc = "Half-word (16 bits)"]
            _16BIT,
            #[doc = "Word (32 bits)"]
            _32BIT,
        }
        impl SIZEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SIZEW::_8BIT => 1,
                    SIZEW::_16BIT => 2,
                    SIZEW::_32BIT => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SIZEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Byte (8 bits)"]
            #[inline]
            pub fn _8bit(self) -> &'a mut W {
                self.variant(SIZEW::_8BIT)
            }
            #[doc = "Half-word (16 bits)"]
            #[inline]
            pub fn _16bit(self) -> &'a mut W {
                self.variant(SIZEW::_16BIT)
            }
            #[doc = "Word (32 bits)"]
            #[inline]
            pub fn _32bit(self) -> &'a mut W {
                self.variant(SIZEW::_32BIT)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Current Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Current Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
        }
    }
    #[doc = "EPI Read Address 1"]
    pub struct RADDR1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read Address 1"]
    pub mod raddr1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RADDR1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Current Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 0:31 - Current Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "EPI Non-Blocking Read Data 1"]
    pub struct RPSTD1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Non-Blocking Read Data 1"]
    pub mod rpstd1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RPSTD1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct POSTCNTR {
            bits: u16,
        }
        impl POSTCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _POSTCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _POSTCNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x1fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:12 - Post Count"]
            #[inline]
            pub fn postcnt(&self) -> POSTCNTR {
                let bits = {
                    const MASK: u16 = 0x1fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                POSTCNTR { bits }
            }
        }
        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 0:12 - Post Count"]
            #[inline]
            pub fn postcnt(&mut self) -> _POSTCNTW {
                _POSTCNTW { w: self }
            }
        }
    }
    #[doc = "EPI Status"]
    pub struct STAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Status"]
    pub mod stat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::STAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACTIVER {
            bits: bool,
        }
        impl ACTIVER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NBRBUSYR {
            bits: bool,
        }
        impl NBRBUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WBUSYR {
            bits: bool,
        }
        impl WBUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INITSEQR {
            bits: bool,
        }
        impl INITSEQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFEMPTYR {
            bits: bool,
        }
        impl XFEMPTYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XFFULLR {
            bits: bool,
        }
        impl XFFULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Register Active"]
            #[inline]
            pub fn active(&self) -> ACTIVER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACTIVER { bits }
            }
            #[doc = "Bit 4 - Non-Blocking Read Busy"]
            #[inline]
            pub fn nbrbusy(&self) -> NBRBUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NBRBUSYR { bits }
            }
            #[doc = "Bit 5 - Write Busy"]
            #[inline]
            pub fn wbusy(&self) -> WBUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WBUSYR { bits }
            }
            #[doc = "Bit 6 - Initialization Sequence"]
            #[inline]
            pub fn initseq(&self) -> INITSEQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INITSEQR { bits }
            }
            #[doc = "Bit 7 - External FIFO Empty"]
            #[inline]
            pub fn xfempty(&self) -> XFEMPTYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFEMPTYR { bits }
            }
            #[doc = "Bit 8 - External FIFO Full"]
            #[inline]
            pub fn xffull(&self) -> XFFULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XFFULLR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Count"]
    pub struct RFIFOCNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Count"]
    pub mod rfifocnt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RFIFOCNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct COUNTR {
            bits: u8,
        }
        impl COUNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - FIFO Count"]
            #[inline]
            pub fn count(&self) -> COUNTR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                COUNTR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO"]
    pub struct READFIFO0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO"]
    pub mod readfifo0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 1"]
    pub struct READFIFO1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 1"]
    pub mod readfifo1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 2"]
    pub struct READFIFO2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 2"]
    pub mod readfifo2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 3"]
    pub struct READFIFO3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 3"]
    pub mod readfifo3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO3 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 4"]
    pub struct READFIFO4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 4"]
    pub mod readfifo4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO4 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 5"]
    pub struct READFIFO5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 5"]
    pub mod readfifo5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO5 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 6"]
    pub struct READFIFO6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 6"]
    pub mod readfifo6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO6 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI Read FIFO Alias 7"]
    pub struct READFIFO7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Read FIFO Alias 7"]
    pub mod readfifo7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::READFIFO7 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reads Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
    }
    #[doc = "EPI FIFO Level Selects"]
    pub struct FIFOLVL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI FIFO Level Selects"]
    pub mod fifolvl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FIFOLVL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `RDFIFO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDFIFOR {
            #[doc = "Trigger when there are 1 or more entries in the NBRFIFO"]
            _1,
            #[doc = "Trigger when there are 2 or more entries in the NBRFIFO"]
            _2,
            #[doc = "Trigger when there are 4 or more entries in the NBRFIFO"]
            _4,
            #[doc = "Trigger when there are 6 or more entries in the NBRFIFO"]
            _6,
            #[doc = "Trigger when there are 7 or more entries in the NBRFIFO"]
            _7,
            #[doc = "Trigger when there are 8 entries in the NBRFIFO"]
            _8,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl RDFIFOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDFIFOR::_1 => 0x01,
                    RDFIFOR::_2 => 0x02,
                    RDFIFOR::_4 => 0x03,
                    RDFIFOR::_6 => 0x04,
                    RDFIFOR::_7 => 0x05,
                    RDFIFOR::_8 => 0x06,
                    RDFIFOR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDFIFOR {
                match value {
                    1 => RDFIFOR::_1,
                    2 => RDFIFOR::_2,
                    3 => RDFIFOR::_4,
                    4 => RDFIFOR::_6,
                    5 => RDFIFOR::_7,
                    6 => RDFIFOR::_8,
                    i => RDFIFOR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == RDFIFOR::_1
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDFIFOR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDFIFOR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDFIFOR::_6
            }
            #[doc = "Checks if the value of the field is `_7`"]
            #[inline]
            pub fn is_7(&self) -> bool {
                *self == RDFIFOR::_7
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDFIFOR::_8
            }
        }
        #[doc = "Possible values of the field `WRFIFO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRFIFOR {
            #[doc = "Interrupt is triggered while WRFIFO is empty."]
            EMPT,
            #[doc = "Interrupt is triggered until there are only two slots available. Thus, trigger is deasserted when there are two WRFIFO entries present. This configuration is optimized for bursts of 2"]
            _2,
            #[doc = "Interrupt is triggered until there is one WRFIFO entry available. This configuration expects only single writes"]
            _1,
            #[doc = "Trigger interrupt when WRFIFO is not full, meaning trigger will continue to assert until there are four entries in the WRFIFO"]
            NFULL,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl WRFIFOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRFIFOR::EMPT => 0,
                    WRFIFOR::_2 => 0x02,
                    WRFIFOR::_1 => 0x03,
                    WRFIFOR::NFULL => 0x04,
                    WRFIFOR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRFIFOR {
                match value {
                    0 => WRFIFOR::EMPT,
                    2 => WRFIFOR::_2,
                    3 => WRFIFOR::_1,
                    4 => WRFIFOR::NFULL,
                    i => WRFIFOR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `EMPT`"]
            #[inline]
            pub fn is_empt(&self) -> bool {
                *self == WRFIFOR::EMPT
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRFIFOR::_2
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == WRFIFOR::_1
            }
            #[doc = "Checks if the value of the field is `NFULL`"]
            #[inline]
            pub fn is_nfull(&self) -> bool {
                *self == WRFIFOR::NFULL
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSERRR {
            bits: bool,
        }
        impl RSERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WFERRR {
            bits: bool,
        }
        impl WFERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `RDFIFO`"]
        pub enum RDFIFOW {
            #[doc = "Trigger when there are 1 or more entries in the NBRFIFO"]
            _1,
            #[doc = "Trigger when there are 2 or more entries in the NBRFIFO"]
            _2,
            #[doc = "Trigger when there are 4 or more entries in the NBRFIFO"]
            _4,
            #[doc = "Trigger when there are 6 or more entries in the NBRFIFO"]
            _6,
            #[doc = "Trigger when there are 7 or more entries in the NBRFIFO"]
            _7,
            #[doc = "Trigger when there are 8 entries in the NBRFIFO"]
            _8,
        }
        impl RDFIFOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDFIFOW::_1 => 1,
                    RDFIFOW::_2 => 2,
                    RDFIFOW::_4 => 3,
                    RDFIFOW::_6 => 4,
                    RDFIFOW::_7 => 5,
                    RDFIFOW::_8 => 6,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDFIFOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDFIFOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDFIFOW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Trigger when there are 1 or more entries in the NBRFIFO"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(RDFIFOW::_1)
            }
            #[doc = "Trigger when there are 2 or more entries in the NBRFIFO"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDFIFOW::_2)
            }
            #[doc = "Trigger when there are 4 or more entries in the NBRFIFO"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDFIFOW::_4)
            }
            #[doc = "Trigger when there are 6 or more entries in the NBRFIFO"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDFIFOW::_6)
            }
            #[doc = "Trigger when there are 7 or more entries in the NBRFIFO"]
            #[inline]
            pub fn _7(self) -> &'a mut W {
                self.variant(RDFIFOW::_7)
            }
            #[doc = "Trigger when there are 8 entries in the NBRFIFO"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDFIFOW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRFIFO`"]
        pub enum WRFIFOW {
            #[doc = "Interrupt is triggered while WRFIFO is empty."]
            EMPT,
            #[doc = "Interrupt is triggered until there are only two slots available. Thus, trigger is deasserted when there are two WRFIFO entries present. This configuration is optimized for bursts of 2"]
            _2,
            #[doc = "Interrupt is triggered until there is one WRFIFO entry available. This configuration expects only single writes"]
            _1,
            #[doc = "Trigger interrupt when WRFIFO is not full, meaning trigger will continue to assert until there are four entries in the WRFIFO"]
            NFULL,
        }
        impl WRFIFOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRFIFOW::EMPT => 0,
                    WRFIFOW::_2 => 2,
                    WRFIFOW::_1 => 3,
                    WRFIFOW::NFULL => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRFIFOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRFIFOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRFIFOW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Interrupt is triggered while WRFIFO is empty."]
            #[inline]
            pub fn empt(self) -> &'a mut W {
                self.variant(WRFIFOW::EMPT)
            }
            #[doc = "Interrupt is triggered until there are only two slots available. Thus, trigger is deasserted when there are two WRFIFO entries present. This configuration is optimized for bursts of 2"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRFIFOW::_2)
            }
            #[doc = "Interrupt is triggered until there is one WRFIFO entry available. This configuration expects only single writes"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(WRFIFOW::_1)
            }
            #[doc = "Trigger interrupt when WRFIFO is not full, meaning trigger will continue to assert until there are four entries in the WRFIFO"]
            #[inline]
            pub fn nfull(self) -> &'a mut W {
                self.variant(WRFIFOW::NFULL)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSERRW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WFERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WFERRW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Read FIFO"]
            #[inline]
            pub fn rdfifo(&self) -> RDFIFOR {
                RDFIFOR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:6 - Write FIFO"]
            #[inline]
            pub fn wrfifo(&self) -> WRFIFOR {
                WRFIFOR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Read Stall Error"]
            #[inline]
            pub fn rserr(&self) -> RSERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSERRR { bits }
            }
            #[doc = "Bit 17 - Write Full Error"]
            #[inline]
            pub fn wferr(&self) -> WFERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WFERRR { bits }
            }
        }
        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 0:2 - Read FIFO"]
            #[inline]
            pub fn rdfifo(&mut self) -> _RDFIFOW {
                _RDFIFOW { w: self }
            }
            #[doc = "Bits 4:6 - Write FIFO"]
            #[inline]
            pub fn wrfifo(&mut self) -> _WRFIFOW {
                _WRFIFOW { w: self }
            }
            #[doc = "Bit 16 - Read Stall Error"]
            #[inline]
            pub fn rserr(&mut self) -> _RSERRW {
                _RSERRW { w: self }
            }
            #[doc = "Bit 17 - Write Full Error"]
            #[inline]
            pub fn wferr(&mut self) -> _WFERRW {
                _WFERRW { w: self }
            }
        }
    }
    #[doc = "EPI Write FIFO Count"]
    pub struct WFIFOCNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Write FIFO Count"]
    pub mod wfifocnt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::WFIFOCNT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WTAVR {
            bits: u8,
        }
        impl WTAVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Available Write Transactions"]
            #[inline]
            pub fn wtav(&self) -> WTAVR {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                WTAVR { bits }
            }
        }
    }
    #[doc = "EPI DMA Transmit Count"]
    pub struct DMATXCNT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI DMA Transmit Count"]
    pub mod dmatxcnt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMATXCNT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXCNTR {
            bits: u16,
        }
        impl TXCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXCNTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - DMA Count"]
            #[inline]
            pub fn txcnt(&self) -> TXCNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                TXCNTR { bits }
            }
        }
        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 0:15 - DMA Count"]
            #[inline]
            pub fn txcnt(&mut self) -> _TXCNTW {
                _TXCNTW { w: self }
            }
        }
    }
    #[doc = "EPI Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRIMR {
            bits: bool,
        }
        impl ERRIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDIMR {
            bits: bool,
        }
        impl RDIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRIMR {
            bits: bool,
        }
        impl WRIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARDIMR {
            bits: bool,
        }
        impl DMARDIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAWRIMR {
            bits: bool,
        }
        impl DMAWRIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARDIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARDIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAWRIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAWRIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Error Interrupt Mask"]
            #[inline]
            pub fn errim(&self) -> ERRIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRIMR { bits }
            }
            #[doc = "Bit 1 - Read FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rdim(&self) -> RDIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDIMR { bits }
            }
            #[doc = "Bit 2 - Write FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn wrim(&self) -> WRIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRIMR { bits }
            }
            #[doc = "Bit 3 - Read uDMA Interrupt Mask"]
            #[inline]
            pub fn dmardim(&self) -> DMARDIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARDIMR { bits }
            }
            #[doc = "Bit 4 - Write uDMA Interrupt Mask"]
            #[inline]
            pub fn dmawrim(&self) -> DMAWRIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAWRIMR { bits }
            }
        }
        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 = "Bit 0 - Error Interrupt Mask"]
            #[inline]
            pub fn errim(&mut self) -> _ERRIMW {
                _ERRIMW { w: self }
            }
            #[doc = "Bit 1 - Read FIFO Full Interrupt Mask"]
            #[inline]
            pub fn rdim(&mut self) -> _RDIMW {
                _RDIMW { w: self }
            }
            #[doc = "Bit 2 - Write FIFO Empty Interrupt Mask"]
            #[inline]
            pub fn wrim(&mut self) -> _WRIMW {
                _WRIMW { w: self }
            }
            #[doc = "Bit 3 - Read uDMA Interrupt Mask"]
            #[inline]
            pub fn dmardim(&mut self) -> _DMARDIMW {
                _DMARDIMW { w: self }
            }
            #[doc = "Bit 4 - Write uDMA Interrupt Mask"]
            #[inline]
            pub fn dmawrim(&mut self) -> _DMAWRIMW {
                _DMAWRIMW { w: self }
            }
        }
    }
    #[doc = "EPI Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRRISR {
            bits: bool,
        }
        impl ERRRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDRISR {
            bits: bool,
        }
        impl RDRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRRISR {
            bits: bool,
        }
        impl WRRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARDRISR {
            bits: bool,
        }
        impl DMARDRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAWRRISR {
            bits: bool,
        }
        impl DMAWRRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Error Raw Interrupt Status"]
            #[inline]
            pub fn errris(&self) -> ERRRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRRISR { bits }
            }
            #[doc = "Bit 1 - Read Raw Interrupt Status"]
            #[inline]
            pub fn rdris(&self) -> RDRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDRISR { bits }
            }
            #[doc = "Bit 2 - Write Raw Interrupt Status"]
            #[inline]
            pub fn wrris(&self) -> WRRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRRISR { bits }
            }
            #[doc = "Bit 3 - Read uDMA Raw Interrupt Status"]
            #[inline]
            pub fn dmardris(&self) -> DMARDRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARDRISR { bits }
            }
            #[doc = "Bit 4 - Write uDMA Raw Interrupt Status"]
            #[inline]
            pub fn dmawrris(&self) -> DMAWRRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAWRRISR { bits }
            }
        }
    }
    #[doc = "EPI Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRMISR {
            bits: bool,
        }
        impl ERRMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDMISR {
            bits: bool,
        }
        impl RDMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRMISR {
            bits: bool,
        }
        impl WRMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARDMISR {
            bits: bool,
        }
        impl DMARDMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAWRMISR {
            bits: bool,
        }
        impl DMAWRMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Error Masked Interrupt Status"]
            #[inline]
            pub fn errmis(&self) -> ERRMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRMISR { bits }
            }
            #[doc = "Bit 1 - Read Masked Interrupt Status"]
            #[inline]
            pub fn rdmis(&self) -> RDMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDMISR { bits }
            }
            #[doc = "Bit 2 - Write Masked Interrupt Status"]
            #[inline]
            pub fn wrmis(&self) -> WRMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRMISR { bits }
            }
            #[doc = "Bit 3 - Read uDMA Masked Interrupt Status"]
            #[inline]
            pub fn dmardmis(&self) -> DMARDMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARDMISR { bits }
            }
            #[doc = "Bit 4 - Write uDMA Masked Interrupt Status"]
            #[inline]
            pub fn dmawrmis(&self) -> DMAWRMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAWRMISR { bits }
            }
        }
    }
    #[doc = "EPI Error and Interrupt Status and Clear"]
    pub struct EISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Error and Interrupt Status and Clear"]
    pub mod eisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TOUTR {
            bits: bool,
        }
        impl TOUTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTALLR {
            bits: bool,
        }
        impl RSTALLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WTFULLR {
            bits: bool,
        }
        impl WTFULLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMARDICR {
            bits: bool,
        }
        impl DMARDICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMAWRICR {
            bits: bool,
        }
        impl DMAWRICR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TOUTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TOUTW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSTALLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSTALLW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WTFULLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WTFULLW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMARDICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMARDICW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DMAWRICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DMAWRICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Timeout Error"]
            #[inline]
            pub fn tout(&self) -> TOUTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TOUTR { bits }
            }
            #[doc = "Bit 1 - Read Stalled Error"]
            #[inline]
            pub fn rstall(&self) -> RSTALLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTALLR { bits }
            }
            #[doc = "Bit 2 - Write FIFO Full Error"]
            #[inline]
            pub fn wtfull(&self) -> WTFULLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WTFULLR { bits }
            }
            #[doc = "Bit 3 - Read uDMA Interrupt Clear"]
            #[inline]
            pub fn dmardic(&self) -> DMARDICR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMARDICR { bits }
            }
            #[doc = "Bit 4 - Write uDMA Interrupt Clear"]
            #[inline]
            pub fn dmawric(&self) -> DMAWRICR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DMAWRICR { bits }
            }
        }
        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 = "Bit 0 - Timeout Error"]
            #[inline]
            pub fn tout(&mut self) -> _TOUTW {
                _TOUTW { w: self }
            }
            #[doc = "Bit 1 - Read Stalled Error"]
            #[inline]
            pub fn rstall(&mut self) -> _RSTALLW {
                _RSTALLW { w: self }
            }
            #[doc = "Bit 2 - Write FIFO Full Error"]
            #[inline]
            pub fn wtfull(&mut self) -> _WTFULLW {
                _WTFULLW { w: self }
            }
            #[doc = "Bit 3 - Read uDMA Interrupt Clear"]
            #[inline]
            pub fn dmardic(&mut self) -> _DMARDICW {
                _DMARDICW { w: self }
            }
            #[doc = "Bit 4 - Write uDMA Interrupt Clear"]
            #[inline]
            pub fn dmawric(&mut self) -> _DMAWRICW {
                _DMAWRICW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Configuration 3"]
    pub struct HB8CFG3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Configuration 3"]
    pub mod hb8cfg3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8CFG3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[7:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[7:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS2n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS2n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS2n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 19 - CS2n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS2n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
        }
        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 0:1 - CS2n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS2n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS2n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 19 - CS2n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS2n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Configuration 3"]
    pub struct HB16CFG3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Configuration 3"]
    pub mod hb16cfg3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16CFG3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct BURSTR {
            bits: bool,
        }
        impl BURSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDCRER {
            bits: bool,
        }
        impl RDCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCRER {
            bits: bool,
        }
        impl WRCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[15:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[15:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BURSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BURSTW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDCREW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCREW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS2n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS2n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS2n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - CS2n Burst Mode"]
            #[inline]
            pub fn burst(&self) -> BURSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BURSTR { bits }
            }
            #[doc = "Bit 17 - CS2n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&self) -> RDCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDCRER { bits }
            }
            #[doc = "Bit 18 - CS2n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&self) -> WRCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCRER { bits }
            }
            #[doc = "Bit 19 - CS2n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS2n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
        }
        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 0:1 - CS2n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS2n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS2n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 16 - CS2n Burst Mode"]
            #[inline]
            pub fn burst(&mut self) -> _BURSTW {
                _BURSTW { w: self }
            }
            #[doc = "Bit 17 - CS2n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&mut self) -> _RDCREW {
                _RDCREW { w: self }
            }
            #[doc = "Bit 18 - CS2n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&mut self) -> _WRCREW {
                _WRCREW { w: self }
            }
            #[doc = "Bit 19 - CS2n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS2n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Configuration 4"]
    pub struct HB16CFG4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Configuration 4"]
    pub mod hb16cfg4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16CFG4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct BURSTR {
            bits: bool,
        }
        impl BURSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDCRER {
            bits: bool,
        }
        impl RDCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCRER {
            bits: bool,
        }
        impl WRCRER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[15:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[15:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[15:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[15:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BURSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BURSTW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDCREW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCREW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS3n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS3n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS3n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - CS3n Burst Mode"]
            #[inline]
            pub fn burst(&self) -> BURSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BURSTR { bits }
            }
            #[doc = "Bit 17 - CS3n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&self) -> RDCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDCRER { bits }
            }
            #[doc = "Bit 18 - CS3n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&self) -> WRCRER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCRER { bits }
            }
            #[doc = "Bit 19 - CS3n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS3n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS3n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
        }
        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 0:1 - CS3n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS3n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS3n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 16 - CS3n Burst Mode"]
            #[inline]
            pub fn burst(&mut self) -> _BURSTW {
                _BURSTW { w: self }
            }
            #[doc = "Bit 17 - CS3n PSRAM Configuration Register Read"]
            #[inline]
            pub fn rdcre(&mut self) -> _RDCREW {
                _RDCREW { w: self }
            }
            #[doc = "Bit 18 - CS3n PSRAM Configuration Register Write"]
            #[inline]
            pub fn wrcre(&mut self) -> _WRCREW {
                _WRCREW { w: self }
            }
            #[doc = "Bit 19 - CS3n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS3n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS3n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Configuration 4"]
    pub struct HB8CFG4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Configuration 4"]
    pub mod hb8cfg4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8CFG4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `MODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MODER {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MODER::ADMUX => 0,
                    MODER::AD => 0x01,
                    MODER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MODER {
                match value {
                    0 => MODER::ADMUX,
                    1 => MODER::AD,
                    i => MODER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ADMUX`"]
            #[inline]
            pub fn is_admux(&self) -> bool {
                *self == MODER::ADMUX
            }
            #[doc = "Checks if the value of the field is `AD`"]
            #[inline]
            pub fn is_ad(&self) -> bool {
                *self == MODER::AD
            }
        }
        #[doc = "Possible values of the field `RDWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RDWSR {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RDWSR::_2 => 0,
                    RDWSR::_4 => 0x01,
                    RDWSR::_6 => 0x02,
                    RDWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RDWSR {
                match value {
                    0 => RDWSR::_2,
                    1 => RDWSR::_4,
                    2 => RDWSR::_6,
                    3 => RDWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == RDWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == RDWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == RDWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == RDWSR::_8
            }
        }
        #[doc = "Possible values of the field `WRWS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WRWSR {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WRWSR::_2 => 0,
                    WRWSR::_4 => 0x01,
                    WRWSR::_6 => 0x02,
                    WRWSR::_8 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WRWSR {
                match value {
                    0 => WRWSR::_2,
                    1 => WRWSR::_4,
                    2 => WRWSR::_6,
                    3 => WRWSR::_8,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == WRWSR::_2
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == WRWSR::_4
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == WRWSR::_6
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == WRWSR::_8
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALEHIGHR {
            bits: bool,
        }
        impl ALEHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDHIGHR {
            bits: bool,
        }
        impl RDHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRHIGHR {
            bits: bool,
        }
        impl WRHIGHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `MODE`"]
        pub enum MODEW {
            #[doc = "ADMUX - AD[7:0]"]
            ADMUX,
            #[doc = "ADNONMUX - D[7:0]"]
            AD,
        }
        impl MODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MODEW::ADMUX => 0,
                    MODEW::AD => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MODEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "ADMUX - AD[7:0]"]
            #[inline]
            pub fn admux(self) -> &'a mut W {
                self.variant(MODEW::ADMUX)
            }
            #[doc = "ADNONMUX - D[7:0]"]
            #[inline]
            pub fn ad(self) -> &'a mut W {
                self.variant(MODEW::AD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RDWS`"]
        pub enum RDWSW {
            #[doc = "Active RDn is 2 EPI clocks"]
            _2,
            #[doc = "Active RDn is 4 EPI clocks"]
            _4,
            #[doc = "Active RDn is 6 EPI clocks"]
            _6,
            #[doc = "Active RDn is 8 EPI clocks"]
            _8,
        }
        impl RDWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RDWSW::_2 => 0,
                    RDWSW::_4 => 1,
                    RDWSW::_6 => 2,
                    RDWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RDWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active RDn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(RDWSW::_2)
            }
            #[doc = "Active RDn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(RDWSW::_4)
            }
            #[doc = "Active RDn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(RDWSW::_6)
            }
            #[doc = "Active RDn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(RDWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WRWS`"]
        pub enum WRWSW {
            #[doc = "Active WRn is 2 EPI clocks"]
            _2,
            #[doc = "Active WRn is 4 EPI clocks"]
            _4,
            #[doc = "Active WRn is 6 EPI clocks"]
            _6,
            #[doc = "Active WRn is 8 EPI clocks"]
            _8,
        }
        impl WRWSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WRWSW::_2 => 0,
                    WRWSW::_4 => 1,
                    WRWSW::_6 => 2,
                    WRWSW::_8 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WRWSW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Active WRn is 2 EPI clocks"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(WRWSW::_2)
            }
            #[doc = "Active WRn is 4 EPI clocks"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(WRWSW::_4)
            }
            #[doc = "Active WRn is 6 EPI clocks"]
            #[inline]
            pub fn _6(self) -> &'a mut W {
                self.variant(WRWSW::_6)
            }
            #[doc = "Active WRn is 8 EPI clocks"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(WRWSW::_8)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALEHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALEHIGHW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDHIGHW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRHIGHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRHIGHW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - CS3n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&self) -> MODER {
                MODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - CS3n Read Wait States"]
            #[inline]
            pub fn rdws(&self) -> RDWSR {
                RDWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - CS3n Write Wait States"]
            #[inline]
            pub fn wrws(&self) -> WRWSR {
                WRWSR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 19 - CS3n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&self) -> ALEHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALEHIGHR { bits }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&self) -> RDHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDHIGHR { bits }
            }
            #[doc = "Bit 21 - CS3n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&self) -> WRHIGHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRHIGHR { bits }
            }
        }
        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 0:1 - CS3n Host Bus Sub-Mode"]
            #[inline]
            pub fn mode(&mut self) -> _MODEW {
                _MODEW { w: self }
            }
            #[doc = "Bits 4:5 - CS3n Read Wait States"]
            #[inline]
            pub fn rdws(&mut self) -> _RDWSW {
                _RDWSW { w: self }
            }
            #[doc = "Bits 6:7 - CS3n Write Wait States"]
            #[inline]
            pub fn wrws(&mut self) -> _WRWSW {
                _WRWSW { w: self }
            }
            #[doc = "Bit 19 - CS3n ALE Strobe Polarity"]
            #[inline]
            pub fn alehigh(&mut self) -> _ALEHIGHW {
                _ALEHIGHW { w: self }
            }
            #[doc = "Bit 20 - CS2n READ Strobe Polarity"]
            #[inline]
            pub fn rdhigh(&mut self) -> _RDHIGHW {
                _RDHIGHW { w: self }
            }
            #[doc = "Bit 21 - CS3n WRITE Strobe Polarity"]
            #[inline]
            pub fn wrhigh(&mut self) -> _WRHIGHW {
                _WRHIGHW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub struct HB8TIME {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub mod hb8time {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8TIME {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS0n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 24:25 - CS0n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS0n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 24:25 - CS0n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub struct HB16TIME {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub mod hb16time {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16TIME {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PSRAMSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PSRAMSZR {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PSRAMSZR::_0 => 0,
                    PSRAMSZR::_128B => 0x01,
                    PSRAMSZR::_256B => 0x02,
                    PSRAMSZR::_512B => 0x03,
                    PSRAMSZR::_1KB => 0x04,
                    PSRAMSZR::_2KB => 0x05,
                    PSRAMSZR::_4KB => 0x06,
                    PSRAMSZR::_8KB => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PSRAMSZR {
                match value {
                    0 => PSRAMSZR::_0,
                    1 => PSRAMSZR::_128B,
                    2 => PSRAMSZR::_256B,
                    3 => PSRAMSZR::_512B,
                    4 => PSRAMSZR::_1KB,
                    5 => PSRAMSZR::_2KB,
                    6 => PSRAMSZR::_4KB,
                    7 => PSRAMSZR::_8KB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PSRAMSZR::_0
            }
            #[doc = "Checks if the value of the field is `_128B`"]
            #[inline]
            pub fn is_128b(&self) -> bool {
                *self == PSRAMSZR::_128B
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == PSRAMSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_512B`"]
            #[inline]
            pub fn is_512b(&self) -> bool {
                *self == PSRAMSZR::_512B
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == PSRAMSZR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == PSRAMSZR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == PSRAMSZR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == PSRAMSZR::_8KB
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PSRAMSZ`"]
        pub enum PSRAMSZW {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PSRAMSZW::_0 => 0,
                    PSRAMSZW::_128B => 1,
                    PSRAMSZW::_256B => 2,
                    PSRAMSZW::_512B => 3,
                    PSRAMSZW::_1KB => 4,
                    PSRAMSZW::_2KB => 5,
                    PSRAMSZW::_4KB => 6,
                    PSRAMSZW::_8KB => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSRAMSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSRAMSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PSRAMSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No row size limitation"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PSRAMSZW::_0)
            }
            #[doc = "128 B"]
            #[inline]
            pub fn _128b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_128B)
            }
            #[doc = "256 B"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_256B)
            }
            #[doc = "512 B"]
            #[inline]
            pub fn _512b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_512B)
            }
            #[doc = "1024 B"]
            #[inline]
            pub fn _1kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_1KB)
            }
            #[doc = "2048 B"]
            #[inline]
            pub fn _2kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_2KB)
            }
            #[doc = "4096 B"]
            #[inline]
            pub fn _4kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_4KB)
            }
            #[doc = "8192 B"]
            #[inline]
            pub fn _8kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_8KB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS0n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&self) -> PSRAMSZR {
                PSRAMSZR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:25 - CS0n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS0n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&mut self) -> _PSRAMSZW {
                _PSRAMSZW { w: self }
            }
            #[doc = "Bits 24:25 - CS0n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub struct HB8TIME2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub mod hb8time2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8TIME2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS1n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS1n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS1n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 24:25 - CS1n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS1n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS1n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS1n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 24:25 - CS1n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub struct HB16TIME2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub mod hb16time2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16TIME2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PSRAMSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PSRAMSZR {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PSRAMSZR::_0 => 0,
                    PSRAMSZR::_128B => 0x01,
                    PSRAMSZR::_256B => 0x02,
                    PSRAMSZR::_512B => 0x03,
                    PSRAMSZR::_1KB => 0x04,
                    PSRAMSZR::_2KB => 0x05,
                    PSRAMSZR::_4KB => 0x06,
                    PSRAMSZR::_8KB => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PSRAMSZR {
                match value {
                    0 => PSRAMSZR::_0,
                    1 => PSRAMSZR::_128B,
                    2 => PSRAMSZR::_256B,
                    3 => PSRAMSZR::_512B,
                    4 => PSRAMSZR::_1KB,
                    5 => PSRAMSZR::_2KB,
                    6 => PSRAMSZR::_4KB,
                    7 => PSRAMSZR::_8KB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PSRAMSZR::_0
            }
            #[doc = "Checks if the value of the field is `_128B`"]
            #[inline]
            pub fn is_128b(&self) -> bool {
                *self == PSRAMSZR::_128B
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == PSRAMSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_512B`"]
            #[inline]
            pub fn is_512b(&self) -> bool {
                *self == PSRAMSZR::_512B
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == PSRAMSZR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == PSRAMSZR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == PSRAMSZR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == PSRAMSZR::_8KB
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PSRAMSZ`"]
        pub enum PSRAMSZW {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PSRAMSZW::_0 => 0,
                    PSRAMSZW::_128B => 1,
                    PSRAMSZW::_256B => 2,
                    PSRAMSZW::_512B => 3,
                    PSRAMSZW::_1KB => 4,
                    PSRAMSZW::_2KB => 5,
                    PSRAMSZW::_4KB => 6,
                    PSRAMSZW::_8KB => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSRAMSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSRAMSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PSRAMSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No row size limitation"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PSRAMSZW::_0)
            }
            #[doc = "128 B"]
            #[inline]
            pub fn _128b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_128B)
            }
            #[doc = "256 B"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_256B)
            }
            #[doc = "512 B"]
            #[inline]
            pub fn _512b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_512B)
            }
            #[doc = "1024 B"]
            #[inline]
            pub fn _1kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_1KB)
            }
            #[doc = "2048 B"]
            #[inline]
            pub fn _2kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_2KB)
            }
            #[doc = "4096 B"]
            #[inline]
            pub fn _4kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_4KB)
            }
            #[doc = "8192 B"]
            #[inline]
            pub fn _8kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_8KB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS1n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS1n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS1n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&self) -> PSRAMSZR {
                PSRAMSZR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:25 - CS1n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS1n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS1n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS1n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&mut self) -> _PSRAMSZW {
                _PSRAMSZW { w: self }
            }
            #[doc = "Bits 24:25 - CS1n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub struct HB16TIME3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub mod hb16time3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16TIME3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PSRAMSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PSRAMSZR {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PSRAMSZR::_0 => 0,
                    PSRAMSZR::_128B => 0x01,
                    PSRAMSZR::_256B => 0x02,
                    PSRAMSZR::_512B => 0x03,
                    PSRAMSZR::_1KB => 0x04,
                    PSRAMSZR::_2KB => 0x05,
                    PSRAMSZR::_4KB => 0x06,
                    PSRAMSZR::_8KB => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PSRAMSZR {
                match value {
                    0 => PSRAMSZR::_0,
                    1 => PSRAMSZR::_128B,
                    2 => PSRAMSZR::_256B,
                    3 => PSRAMSZR::_512B,
                    4 => PSRAMSZR::_1KB,
                    5 => PSRAMSZR::_2KB,
                    6 => PSRAMSZR::_4KB,
                    7 => PSRAMSZR::_8KB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PSRAMSZR::_0
            }
            #[doc = "Checks if the value of the field is `_128B`"]
            #[inline]
            pub fn is_128b(&self) -> bool {
                *self == PSRAMSZR::_128B
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == PSRAMSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_512B`"]
            #[inline]
            pub fn is_512b(&self) -> bool {
                *self == PSRAMSZR::_512B
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == PSRAMSZR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == PSRAMSZR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == PSRAMSZR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == PSRAMSZR::_8KB
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PSRAMSZ`"]
        pub enum PSRAMSZW {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PSRAMSZW::_0 => 0,
                    PSRAMSZW::_128B => 1,
                    PSRAMSZW::_256B => 2,
                    PSRAMSZW::_512B => 3,
                    PSRAMSZW::_1KB => 4,
                    PSRAMSZW::_2KB => 5,
                    PSRAMSZW::_4KB => 6,
                    PSRAMSZW::_8KB => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSRAMSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSRAMSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PSRAMSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No row size limitation"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PSRAMSZW::_0)
            }
            #[doc = "128 B"]
            #[inline]
            pub fn _128b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_128B)
            }
            #[doc = "256 B"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_256B)
            }
            #[doc = "512 B"]
            #[inline]
            pub fn _512b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_512B)
            }
            #[doc = "1024 B"]
            #[inline]
            pub fn _1kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_1KB)
            }
            #[doc = "2048 B"]
            #[inline]
            pub fn _2kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_2KB)
            }
            #[doc = "4096 B"]
            #[inline]
            pub fn _4kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_4KB)
            }
            #[doc = "8192 B"]
            #[inline]
            pub fn _8kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_8KB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS2n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS2n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS2n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&self) -> PSRAMSZR {
                PSRAMSZR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:25 - CS2n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS2n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS2n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS2n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&mut self) -> _PSRAMSZW {
                _PSRAMSZW { w: self }
            }
            #[doc = "Bits 24:25 - CS2n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub struct HB8TIME3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub mod hb8time3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8TIME3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS2n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS2n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS2n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 24:25 - CS2n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS2n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS2n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS2n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 24:25 - CS2n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub struct HB8TIME4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 8 Timing Extension"]
    pub mod hb8time4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB8TIME4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS3n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS3n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS3n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 24:25 - CS3n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS3n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS3n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS3n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 24:25 - CS3n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub struct HB16TIME4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus 16 Timing Extension"]
    pub mod hb16time4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HB16TIME4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RDWSMR {
            bits: bool,
        }
        impl RDWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRWSMR {
            bits: bool,
        }
        impl WRWSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAPWIDTHR {
            bits: u8,
        }
        impl CAPWIDTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `PSRAMSZ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PSRAMSZR {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PSRAMSZR::_0 => 0,
                    PSRAMSZR::_128B => 0x01,
                    PSRAMSZR::_256B => 0x02,
                    PSRAMSZR::_512B => 0x03,
                    PSRAMSZR::_1KB => 0x04,
                    PSRAMSZR::_2KB => 0x05,
                    PSRAMSZR::_4KB => 0x06,
                    PSRAMSZR::_8KB => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PSRAMSZR {
                match value {
                    0 => PSRAMSZR::_0,
                    1 => PSRAMSZR::_128B,
                    2 => PSRAMSZR::_256B,
                    3 => PSRAMSZR::_512B,
                    4 => PSRAMSZR::_1KB,
                    5 => PSRAMSZR::_2KB,
                    6 => PSRAMSZR::_4KB,
                    7 => PSRAMSZR::_8KB,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PSRAMSZR::_0
            }
            #[doc = "Checks if the value of the field is `_128B`"]
            #[inline]
            pub fn is_128b(&self) -> bool {
                *self == PSRAMSZR::_128B
            }
            #[doc = "Checks if the value of the field is `_256B`"]
            #[inline]
            pub fn is_256b(&self) -> bool {
                *self == PSRAMSZR::_256B
            }
            #[doc = "Checks if the value of the field is `_512B`"]
            #[inline]
            pub fn is_512b(&self) -> bool {
                *self == PSRAMSZR::_512B
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == PSRAMSZR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == PSRAMSZR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == PSRAMSZR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == PSRAMSZR::_8KB
            }
        }
        #[doc = r" Value of the field"]
        pub struct IRDYDLYR {
            bits: u8,
        }
        impl IRDYDLYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RDWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RDWSMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRWSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRWSMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAPWIDTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAPWIDTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PSRAMSZ`"]
        pub enum PSRAMSZW {
            #[doc = "No row size limitation"]
            _0,
            #[doc = "128 B"]
            _128B,
            #[doc = "256 B"]
            _256B,
            #[doc = "512 B"]
            _512B,
            #[doc = "1024 B"]
            _1KB,
            #[doc = "2048 B"]
            _2KB,
            #[doc = "4096 B"]
            _4KB,
            #[doc = "8192 B"]
            _8KB,
        }
        impl PSRAMSZW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PSRAMSZW::_0 => 0,
                    PSRAMSZW::_128B => 1,
                    PSRAMSZW::_256B => 2,
                    PSRAMSZW::_512B => 3,
                    PSRAMSZW::_1KB => 4,
                    PSRAMSZW::_2KB => 5,
                    PSRAMSZW::_4KB => 6,
                    PSRAMSZW::_8KB => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSRAMSZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSRAMSZW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PSRAMSZW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No row size limitation"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(PSRAMSZW::_0)
            }
            #[doc = "128 B"]
            #[inline]
            pub fn _128b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_128B)
            }
            #[doc = "256 B"]
            #[inline]
            pub fn _256b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_256B)
            }
            #[doc = "512 B"]
            #[inline]
            pub fn _512b(self) -> &'a mut W {
                self.variant(PSRAMSZW::_512B)
            }
            #[doc = "1024 B"]
            #[inline]
            pub fn _1kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_1KB)
            }
            #[doc = "2048 B"]
            #[inline]
            pub fn _2kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_2KB)
            }
            #[doc = "4096 B"]
            #[inline]
            pub fn _4kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_4KB)
            }
            #[doc = "8192 B"]
            #[inline]
            pub fn _8kb(self) -> &'a mut W {
                self.variant(PSRAMSZW::_8KB)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IRDYDLYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IRDYDLYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CS3n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&self) -> RDWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RDWSMR { bits }
            }
            #[doc = "Bit 4 - CS3n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&self) -> WRWSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRWSMR { bits }
            }
            #[doc = "Bits 12:13 - CS3n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&self) -> CAPWIDTHR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CAPWIDTHR { bits }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&self) -> PSRAMSZR {
                PSRAMSZR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:25 - CS3n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&self) -> IRDYDLYR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                IRDYDLYR { bits }
            }
        }
        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 = "Bit 0 - CS3n Read Wait State Minus One"]
            #[inline]
            pub fn rdwsm(&mut self) -> _RDWSMW {
                _RDWSMW { w: self }
            }
            #[doc = "Bit 4 - CS3n Write Wait State Minus One"]
            #[inline]
            pub fn wrwsm(&mut self) -> _WRWSMW {
                _WRWSMW { w: self }
            }
            #[doc = "Bits 12:13 - CS3n Inter-transfer Capture Width"]
            #[inline]
            pub fn capwidth(&mut self) -> _CAPWIDTHW {
                _CAPWIDTHW { w: self }
            }
            #[doc = "Bits 16:18 - PSRAM Row Size"]
            #[inline]
            pub fn psramsz(&mut self) -> _PSRAMSZW {
                _PSRAMSZW { w: self }
            }
            #[doc = "Bits 24:25 - CS3n Input Ready Delay"]
            #[inline]
            pub fn irdydly(&mut self) -> _IRDYDLYW {
                _IRDYDLYW { w: self }
            }
        }
    }
    #[doc = "EPI Host-Bus PSRAM"]
    pub struct HBPSRAM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Host-Bus PSRAM"]
    pub mod hbpsram {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HBPSRAM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CRR {
            bits: u32,
        }
        impl CRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x001f_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:20 - PSRAM Config Register"]
            #[inline]
            pub fn cr(&self) -> CRR {
                let bits = {
                    const MASK: u32 = 0x001f_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CRR { bits }
            }
        }
        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 0:20 - PSRAM Config Register"]
            #[inline]
            pub fn cr(&mut self) -> _CRW {
                _CRW { w: self }
            }
        }
    }
}
#[doc = "TIMER6"]
pub struct TIMER6 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER6 {}
impl TIMER6 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x400e_0000 as *const _
    }
}
impl Deref for TIMER6 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER6::ptr() }
    }
}
#[doc = "TIMER7"]
pub struct TIMER7 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for TIMER7 {}
impl TIMER7 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const timer0::RegisterBlock {
        0x400e_1000 as *const _
    }
}
impl Deref for TIMER7 {
    type Target = timer0::RegisterBlock;
    fn deref(&self) -> &timer0::RegisterBlock {
        unsafe { &*TIMER7::ptr() }
    }
}
#[doc = "EMAC register offsets"]
pub struct EMAC0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for EMAC0 {}
impl EMAC0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const emac0::RegisterBlock {
        0x400e_c000 as *const _
    }
}
impl Deref for EMAC0 {
    type Target = emac0::RegisterBlock;
    fn deref(&self) -> &emac0::RegisterBlock {
        unsafe { &*EMAC0::ptr() }
    }
}
#[doc = "EMAC register offsets"]
pub mod emac0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Ethernet MAC Configuration"]
        pub cfg: CFG,
        #[doc = "0x04 - Ethernet MAC Frame Filter"]
        pub framefltr: FRAMEFLTR,
        #[doc = "0x08 - Ethernet MAC Hash Table High"]
        pub hashtblh: HASHTBLH,
        #[doc = "0x0c - Ethernet MAC Hash Table Low"]
        pub hashtbll: HASHTBLL,
        #[doc = "0x10 - Ethernet MAC MII Address"]
        pub miiaddr: MIIADDR,
        #[doc = "0x14 - Ethernet MAC MII Data Register"]
        pub miidata: MIIDATA,
        #[doc = "0x18 - Ethernet MAC Flow Control"]
        pub flowctl: FLOWCTL,
        #[doc = "0x1c - Ethernet MAC VLAN Tag"]
        pub vlantg: VLANTG,
        _reserved0: [u8; 4usize],
        #[doc = "0x24 - Ethernet MAC Status"]
        pub status: STATUS,
        #[doc = "0x28 - Ethernet MAC Remote Wake-Up Frame Filter"]
        pub rwuff: RWUFF,
        #[doc = "0x2c - Ethernet MAC PMT Control and Status Register"]
        pub pmtctlstat: PMTCTLSTAT,
        _reserved1: [u8; 8usize],
        #[doc = "0x38 - Ethernet MAC Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x3c - Ethernet MAC Interrupt Mask"]
        pub im: IM,
        #[doc = "0x40 - Ethernet MAC Address 0 High"]
        pub addr0h: ADDR0H,
        #[doc = "0x44 - Ethernet MAC Address 0 Low Register"]
        pub addr0l: ADDR0L,
        #[doc = "0x48 - Ethernet MAC Address 1 High"]
        pub addr1h: ADDR1H,
        #[doc = "0x4c - Ethernet MAC Address 1 Low"]
        pub addr1l: ADDR1L,
        #[doc = "0x50 - Ethernet MAC Address 2 High"]
        pub addr2h: ADDR2H,
        #[doc = "0x54 - Ethernet MAC Address 2 Low"]
        pub addr2l: ADDR2L,
        #[doc = "0x58 - Ethernet MAC Address 3 High"]
        pub addr3h: ADDR3H,
        #[doc = "0x5c - Ethernet MAC Address 3 Low"]
        pub addr3l: ADDR3L,
        _reserved2: [u8; 124usize],
        #[doc = "0xdc - Ethernet MAC Watchdog Timeout"]
        pub wdogto: WDOGTO,
        _reserved3: [u8; 32usize],
        #[doc = "0x100 - Ethernet MAC MMC Control"]
        pub mmcctrl: MMCCTRL,
        #[doc = "0x104 - Ethernet MAC MMC Receive Raw Interrupt Status"]
        pub mmcrxris: MMCRXRIS,
        #[doc = "0x108 - Ethernet MAC MMC Transmit Raw Interrupt Status"]
        pub mmctxris: MMCTXRIS,
        #[doc = "0x10c - Ethernet MAC MMC Receive Interrupt Mask"]
        pub mmcrxim: MMCRXIM,
        #[doc = "0x110 - Ethernet MAC MMC Transmit Interrupt Mask"]
        pub mmctxim: MMCTXIM,
        _reserved4: [u8; 4usize],
        #[doc = "0x118 - Ethernet MAC Transmit Frame Count for Good and Bad Frames"]
        pub txcntgb: TXCNTGB,
        _reserved5: [u8; 48usize],
        #[doc = "0x14c - Ethernet MAC Transmit Frame Count for Frames Transmitted after Single Collision"]
        pub txcntscol: TXCNTSCOL,
        #[doc = "0x150 - Ethernet MAC Transmit Frame Count for Frames Transmitted after Multiple Collisions"]
        pub txcntmcol: TXCNTMCOL,
        _reserved6: [u8; 16usize],
        #[doc = "0x164 - Ethernet MAC Transmit Octet Count Good"]
        pub txoctcntg: TXOCTCNTG,
        _reserved7: [u8; 24usize],
        #[doc = "0x180 - Ethernet MAC Receive Frame Count for Good and Bad Frames"]
        pub rxcntgb: RXCNTGB,
        _reserved8: [u8; 16usize],
        #[doc = "0x194 - Ethernet MAC Receive Frame Count for CRC Error Frames"]
        pub rxcntcrcerr: RXCNTCRCERR,
        #[doc = "0x198 - Ethernet MAC Receive Frame Count for Alignment Error Frames"]
        pub rxcntalgnerr: RXCNTALGNERR,
        _reserved9: [u8; 40usize],
        #[doc = "0x1c4 - Ethernet MAC Receive Frame Count for Good Unicast Frames"]
        pub rxcntguni: RXCNTGUNI,
        _reserved10: [u8; 956usize],
        #[doc = "0x584 - Ethernet MAC VLAN Tag Inclusion or Replacement"]
        pub vlnincrep: VLNINCREP,
        #[doc = "0x588 - Ethernet MAC VLAN Hash Table"]
        pub vlanhash: VLANHASH,
        _reserved11: [u8; 372usize],
        #[doc = "0x700 - Ethernet MAC Timestamp Control"]
        pub timstctrl: TIMSTCTRL,
        #[doc = "0x704 - Ethernet MAC Sub-Second Increment"]
        pub subsecinc: SUBSECINC,
        #[doc = "0x708 - Ethernet MAC System Time - Seconds"]
        pub timsec: TIMSEC,
        #[doc = "0x70c - Ethernet MAC System Time - Nanoseconds"]
        pub timnano: TIMNANO,
        #[doc = "0x710 - Ethernet MAC System Time - Seconds Update"]
        pub timsecu: TIMSECU,
        #[doc = "0x714 - Ethernet MAC System Time - Nanoseconds Update"]
        pub timnanou: TIMNANOU,
        #[doc = "0x718 - Ethernet MAC Timestamp Addend"]
        pub timadd: TIMADD,
        #[doc = "0x71c - Ethernet MAC Target Time Seconds"]
        pub targsec: TARGSEC,
        #[doc = "0x720 - Ethernet MAC Target Time Nanoseconds"]
        pub targnano: TARGNANO,
        #[doc = "0x724 - Ethernet MAC System Time-Higher Word Seconds"]
        pub hwordsec: HWORDSEC,
        #[doc = "0x728 - Ethernet MAC Timestamp Status"]
        pub timstat: TIMSTAT,
        #[doc = "0x72c - Ethernet MAC PPS Control"]
        pub ppsctrl: PPSCTRL,
        _reserved12: [u8; 48usize],
        #[doc = "0x760 - Ethernet MAC PPS0 Interval"]
        pub pps0intvl: PPS0INTVL,
        #[doc = "0x764 - Ethernet MAC PPS0 Width"]
        pub pps0width: PPS0WIDTH,
        _reserved13: [u8; 1176usize],
        #[doc = "0xc00 - Ethernet MAC DMA Bus Mode"]
        pub dmabusmod: DMABUSMOD,
        #[doc = "0xc04 - Ethernet MAC Transmit Poll Demand"]
        pub txpolld: TXPOLLD,
        #[doc = "0xc08 - Ethernet MAC Receive Poll Demand"]
        pub rxpolld: RXPOLLD,
        #[doc = "0xc0c - Ethernet MAC Receive Descriptor List Address"]
        pub rxdladdr: RXDLADDR,
        #[doc = "0xc10 - Ethernet MAC Transmit Descriptor List Address"]
        pub txdladdr: TXDLADDR,
        #[doc = "0xc14 - Ethernet MAC DMA Interrupt Status"]
        pub dmaris: DMARIS,
        #[doc = "0xc18 - Ethernet MAC DMA Operation Mode"]
        pub dmaopmode: DMAOPMODE,
        #[doc = "0xc1c - Ethernet MAC DMA Interrupt Mask Register"]
        pub dmaim: DMAIM,
        #[doc = "0xc20 - Ethernet MAC Missed Frame and Buffer Overflow Counter"]
        pub mfboc: MFBOC,
        #[doc = "0xc24 - Ethernet MAC Receive Interrupt Watchdog Timer"]
        pub rxintwdt: RXINTWDT,
        _reserved14: [u8; 32usize],
        #[doc = "0xc48 - Ethernet MAC Current Host Transmit Descriptor"]
        pub hostxdesc: HOSTXDESC,
        #[doc = "0xc4c - Ethernet MAC Current Host Receive Descriptor"]
        pub hosrxdesc: HOSRXDESC,
        #[doc = "0xc50 - Ethernet MAC Current Host Transmit Buffer Address"]
        pub hostxba: HOSTXBA,
        #[doc = "0xc54 - Ethernet MAC Current Host Receive Buffer Address"]
        pub hosrxba: HOSRXBA,
        _reserved15: [u8; 872usize],
        #[doc = "0xfc0 - Ethernet MAC Peripheral Property Register"]
        pub pp: PP,
        #[doc = "0xfc4 - Ethernet MAC Peripheral Configuration Register"]
        pub pc: PC,
        #[doc = "0xfc8 - Ethernet MAC Clock Configuration Register"]
        pub cc: CC,
        _reserved16: [u8; 4usize],
        #[doc = "0xfd0 - Ethernet PHY Raw Interrupt Status"]
        pub ephyris: EPHYRIS,
        #[doc = "0xfd4 - Ethernet PHY Interrupt Mask"]
        pub ephyim: EPHYIM,
        #[doc = "0xfd8 - Ethernet PHY Masked Interrupt Status and Clear"]
        pub ephymisc: EPHYMISC,
    }
    #[doc = "Ethernet MAC Configuration"]
    pub struct CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Configuration"]
    pub mod cfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PRELEN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PRELENR {
            #[doc = "7 bytes of preamble"]
            _7,
            #[doc = "5 bytes of preamble"]
            _5,
            #[doc = "3 bytes of preamble"]
            _3,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PRELENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PRELENR::_7 => 0,
                    PRELENR::_5 => 0x01,
                    PRELENR::_3 => 0x02,
                    PRELENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PRELENR {
                match value {
                    0 => PRELENR::_7,
                    1 => PRELENR::_5,
                    2 => PRELENR::_3,
                    i => PRELENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_7`"]
            #[inline]
            pub fn is_7(&self) -> bool {
                *self == PRELENR::_7
            }
            #[doc = "Checks if the value of the field is `_5`"]
            #[inline]
            pub fn is_5(&self) -> bool {
                *self == PRELENR::_5
            }
            #[doc = "Checks if the value of the field is `_3`"]
            #[inline]
            pub fn is_3(&self) -> bool {
                *self == PRELENR::_3
            }
        }
        #[doc = r" Value of the field"]
        pub struct RER {
            bits: bool,
        }
        impl RER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TER {
            bits: bool,
        }
        impl TER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DCR {
            bits: bool,
        }
        impl DCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `BL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BLR {
            #[doc = "k = min (n,10)"]
            _1024,
            #[doc = "k = min (n,8)"]
            _256,
            #[doc = "k = min (n,4)"]
            _8,
            #[doc = "k = min (n,1)"]
            _2,
        }
        impl BLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BLR::_1024 => 0,
                    BLR::_256 => 0x01,
                    BLR::_8 => 0x02,
                    BLR::_2 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BLR {
                match value {
                    0 => BLR::_1024,
                    1 => BLR::_256,
                    2 => BLR::_8,
                    3 => BLR::_2,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_1024`"]
            #[inline]
            pub fn is_1024(&self) -> bool {
                *self == BLR::_1024
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == BLR::_256
            }
            #[doc = "Checks if the value of the field is `_8`"]
            #[inline]
            pub fn is_8(&self) -> bool {
                *self == BLR::_8
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == BLR::_2
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACSR {
            bits: bool,
        }
        impl ACSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DRR {
            bits: bool,
        }
        impl DRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IPCR {
            bits: bool,
        }
        impl IPCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DUPMR {
            bits: bool,
        }
        impl DUPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOOPBMR {
            bits: bool,
        }
        impl LOOPBMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DROR {
            bits: bool,
        }
        impl DROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FESR {
            bits: bool,
        }
        impl FESR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PSR {
            bits: bool,
        }
        impl PSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DISCRSR {
            bits: bool,
        }
        impl DISCRSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `IFG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum IFGR {
            #[doc = "96 bit times"]
            _96,
            #[doc = "88 bit times"]
            _88,
            #[doc = "80 bit times"]
            _80,
            #[doc = "72 bit times"]
            _72,
            #[doc = "64 bit times"]
            _64,
            #[doc = "56 bit times"]
            _56,
            #[doc = "48 bit times"]
            _48,
            #[doc = "40 bit times"]
            _40,
        }
        impl IFGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    IFGR::_96 => 0,
                    IFGR::_88 => 0x01,
                    IFGR::_80 => 0x02,
                    IFGR::_72 => 0x03,
                    IFGR::_64 => 0x04,
                    IFGR::_56 => 0x05,
                    IFGR::_48 => 0x06,
                    IFGR::_40 => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> IFGR {
                match value {
                    0 => IFGR::_96,
                    1 => IFGR::_88,
                    2 => IFGR::_80,
                    3 => IFGR::_72,
                    4 => IFGR::_64,
                    5 => IFGR::_56,
                    6 => IFGR::_48,
                    7 => IFGR::_40,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_96`"]
            #[inline]
            pub fn is_96(&self) -> bool {
                *self == IFGR::_96
            }
            #[doc = "Checks if the value of the field is `_88`"]
            #[inline]
            pub fn is_88(&self) -> bool {
                *self == IFGR::_88
            }
            #[doc = "Checks if the value of the field is `_80`"]
            #[inline]
            pub fn is_80(&self) -> bool {
                *self == IFGR::_80
            }
            #[doc = "Checks if the value of the field is `_72`"]
            #[inline]
            pub fn is_72(&self) -> bool {
                *self == IFGR::_72
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == IFGR::_64
            }
            #[doc = "Checks if the value of the field is `_56`"]
            #[inline]
            pub fn is_56(&self) -> bool {
                *self == IFGR::_56
            }
            #[doc = "Checks if the value of the field is `_48`"]
            #[inline]
            pub fn is_48(&self) -> bool {
                *self == IFGR::_48
            }
            #[doc = "Checks if the value of the field is `_40`"]
            #[inline]
            pub fn is_40(&self) -> bool {
                *self == IFGR::_40
            }
        }
        #[doc = r" Value of the field"]
        pub struct JFENR {
            bits: bool,
        }
        impl JFENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct JDR {
            bits: bool,
        }
        impl JDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDDISR {
            bits: bool,
        }
        impl WDDISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSTR {
            bits: bool,
        }
        impl CSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TWOKPENR {
            bits: bool,
        }
        impl TWOKPENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `PRELEN`"]
        pub enum PRELENW {
            #[doc = "7 bytes of preamble"]
            _7,
            #[doc = "5 bytes of preamble"]
            _5,
            #[doc = "3 bytes of preamble"]
            _3,
        }
        impl PRELENW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PRELENW::_7 => 0,
                    PRELENW::_5 => 1,
                    PRELENW::_3 => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PRELENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PRELENW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PRELENW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "7 bytes of preamble"]
            #[inline]
            pub fn _7(self) -> &'a mut W {
                self.variant(PRELENW::_7)
            }
            #[doc = "5 bytes of preamble"]
            #[inline]
            pub fn _5(self) -> &'a mut W {
                self.variant(PRELENW::_5)
            }
            #[doc = "3 bytes of preamble"]
            #[inline]
            pub fn _3(self) -> &'a mut W {
                self.variant(PRELENW::_3)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _REW<'a> {
            w: &'a mut W,
        }
        impl<'a> _REW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TEW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DCW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BL`"]
        pub enum BLW {
            #[doc = "k = min (n,10)"]
            _1024,
            #[doc = "k = min (n,8)"]
            _256,
            #[doc = "k = min (n,4)"]
            _8,
            #[doc = "k = min (n,1)"]
            _2,
        }
        impl BLW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BLW::_1024 => 0,
                    BLW::_256 => 1,
                    BLW::_8 => 2,
                    BLW::_2 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BLW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BLW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "k = min (n,10)"]
            #[inline]
            pub fn _1024(self) -> &'a mut W {
                self.variant(BLW::_1024)
            }
            #[doc = "k = min (n,8)"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(BLW::_256)
            }
            #[doc = "k = min (n,4)"]
            #[inline]
            pub fn _8(self) -> &'a mut W {
                self.variant(BLW::_8)
            }
            #[doc = "k = min (n,1)"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(BLW::_2)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _ACSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DRW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IPCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IPCW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DUPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DUPMW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOOPBMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOOPBMW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DROW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FESW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FESW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DISCRSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DISCRSW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `IFG`"]
        pub enum IFGW {
            #[doc = "96 bit times"]
            _96,
            #[doc = "88 bit times"]
            _88,
            #[doc = "80 bit times"]
            _80,
            #[doc = "72 bit times"]
            _72,
            #[doc = "64 bit times"]
            _64,
            #[doc = "56 bit times"]
            _56,
            #[doc = "48 bit times"]
            _48,
            #[doc = "40 bit times"]
            _40,
        }
        impl IFGW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    IFGW::_96 => 0,
                    IFGW::_88 => 1,
                    IFGW::_80 => 2,
                    IFGW::_72 => 3,
                    IFGW::_64 => 4,
                    IFGW::_56 => 5,
                    IFGW::_48 => 6,
                    IFGW::_40 => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _IFGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IFGW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: IFGW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "96 bit times"]
            #[inline]
            pub fn _96(self) -> &'a mut W {
                self.variant(IFGW::_96)
            }
            #[doc = "88 bit times"]
            #[inline]
            pub fn _88(self) -> &'a mut W {
                self.variant(IFGW::_88)
            }
            #[doc = "80 bit times"]
            #[inline]
            pub fn _80(self) -> &'a mut W {
                self.variant(IFGW::_80)
            }
            #[doc = "72 bit times"]
            #[inline]
            pub fn _72(self) -> &'a mut W {
                self.variant(IFGW::_72)
            }
            #[doc = "64 bit times"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(IFGW::_64)
            }
            #[doc = "56 bit times"]
            #[inline]
            pub fn _56(self) -> &'a mut W {
                self.variant(IFGW::_56)
            }
            #[doc = "48 bit times"]
            #[inline]
            pub fn _48(self) -> &'a mut W {
                self.variant(IFGW::_48)
            }
            #[doc = "40 bit times"]
            #[inline]
            pub fn _40(self) -> &'a mut W {
                self.variant(IFGW::_40)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _JFENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _JFENW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _JDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _JDW<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDDISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDDISW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSTW<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TWOKPENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TWOKPENW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Preamble Length for Transmit Frames"]
            #[inline]
            pub fn prelen(&self) -> PRELENR {
                PRELENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - Receiver Enable"]
            #[inline]
            pub fn re(&self) -> RER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RER { bits }
            }
            #[doc = "Bit 3 - Transmitter Enable"]
            #[inline]
            pub fn te(&self) -> TER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TER { bits }
            }
            #[doc = "Bit 4 - Deferral Check"]
            #[inline]
            pub fn dc(&self) -> DCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DCR { bits }
            }
            #[doc = "Bits 5:6 - Back-Off Limit"]
            #[inline]
            pub fn bl(&self) -> BLR {
                BLR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Automatic Pad or CRC Stripping"]
            #[inline]
            pub fn acs(&self) -> ACSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACSR { bits }
            }
            #[doc = "Bit 9 - Disable Retry"]
            #[inline]
            pub fn dr(&self) -> DRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DRR { bits }
            }
            #[doc = "Bit 10 - Checksum Offload"]
            #[inline]
            pub fn ipc(&self) -> IPCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IPCR { bits }
            }
            #[doc = "Bit 11 - Duplex Mode"]
            #[inline]
            pub fn dupm(&self) -> DUPMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DUPMR { bits }
            }
            #[doc = "Bit 12 - Loopback Mode"]
            #[inline]
            pub fn loopbm(&self) -> LOOPBMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOOPBMR { bits }
            }
            #[doc = "Bit 13 - Disable Receive Own"]
            #[inline]
            pub fn dro(&self) -> DROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DROR { bits }
            }
            #[doc = "Bit 14 - Speed"]
            #[inline]
            pub fn fes(&self) -> FESR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FESR { bits }
            }
            #[doc = "Bit 15 - Port Select"]
            #[inline]
            pub fn ps(&self) -> PSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PSR { bits }
            }
            #[doc = "Bit 16 - Disable Carrier Sense During Transmission"]
            #[inline]
            pub fn discrs(&self) -> DISCRSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DISCRSR { bits }
            }
            #[doc = "Bits 17:19 - Inter-Frame Gap (IFG)"]
            #[inline]
            pub fn ifg(&self) -> IFGR {
                IFGR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 20 - Jumbo Frame Enable"]
            #[inline]
            pub fn jfen(&self) -> JFENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                JFENR { bits }
            }
            #[doc = "Bit 22 - Jabber Disable"]
            #[inline]
            pub fn jd(&self) -> JDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                JDR { bits }
            }
            #[doc = "Bit 23 - Watchdog Disable"]
            #[inline]
            pub fn wddis(&self) -> WDDISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDDISR { bits }
            }
            #[doc = "Bit 25 - CRC Stripping for Type Frames"]
            #[inline]
            pub fn cst(&self) -> CSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSTR { bits }
            }
            #[doc = "Bit 27 - IEEE 802"]
            #[inline]
            pub fn twokpen(&self) -> TWOKPENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TWOKPENR { bits }
            }
        }
        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 0:1 - Preamble Length for Transmit Frames"]
            #[inline]
            pub fn prelen(&mut self) -> _PRELENW {
                _PRELENW { w: self }
            }
            #[doc = "Bit 2 - Receiver Enable"]
            #[inline]
            pub fn re(&mut self) -> _REW {
                _REW { w: self }
            }
            #[doc = "Bit 3 - Transmitter Enable"]
            #[inline]
            pub fn te(&mut self) -> _TEW {
                _TEW { w: self }
            }
            #[doc = "Bit 4 - Deferral Check"]
            #[inline]
            pub fn dc(&mut self) -> _DCW {
                _DCW { w: self }
            }
            #[doc = "Bits 5:6 - Back-Off Limit"]
            #[inline]
            pub fn bl(&mut self) -> _BLW {
                _BLW { w: self }
            }
            #[doc = "Bit 7 - Automatic Pad or CRC Stripping"]
            #[inline]
            pub fn acs(&mut self) -> _ACSW {
                _ACSW { w: self }
            }
            #[doc = "Bit 9 - Disable Retry"]
            #[inline]
            pub fn dr(&mut self) -> _DRW {
                _DRW { w: self }
            }
            #[doc = "Bit 10 - Checksum Offload"]
            #[inline]
            pub fn ipc(&mut self) -> _IPCW {
                _IPCW { w: self }
            }
            #[doc = "Bit 11 - Duplex Mode"]
            #[inline]
            pub fn dupm(&mut self) -> _DUPMW {
                _DUPMW { w: self }
            }
            #[doc = "Bit 12 - Loopback Mode"]
            #[inline]
            pub fn loopbm(&mut self) -> _LOOPBMW {
                _LOOPBMW { w: self }
            }
            #[doc = "Bit 13 - Disable Receive Own"]
            #[inline]
            pub fn dro(&mut self) -> _DROW {
                _DROW { w: self }
            }
            #[doc = "Bit 14 - Speed"]
            #[inline]
            pub fn fes(&mut self) -> _FESW {
                _FESW { w: self }
            }
            #[doc = "Bit 15 - Port Select"]
            #[inline]
            pub fn ps(&mut self) -> _PSW {
                _PSW { w: self }
            }
            #[doc = "Bit 16 - Disable Carrier Sense During Transmission"]
            #[inline]
            pub fn discrs(&mut self) -> _DISCRSW {
                _DISCRSW { w: self }
            }
            #[doc = "Bits 17:19 - Inter-Frame Gap (IFG)"]
            #[inline]
            pub fn ifg(&mut self) -> _IFGW {
                _IFGW { w: self }
            }
            #[doc = "Bit 20 - Jumbo Frame Enable"]
            #[inline]
            pub fn jfen(&mut self) -> _JFENW {
                _JFENW { w: self }
            }
            #[doc = "Bit 22 - Jabber Disable"]
            #[inline]
            pub fn jd(&mut self) -> _JDW {
                _JDW { w: self }
            }
            #[doc = "Bit 23 - Watchdog Disable"]
            #[inline]
            pub fn wddis(&mut self) -> _WDDISW {
                _WDDISW { w: self }
            }
            #[doc = "Bit 25 - CRC Stripping for Type Frames"]
            #[inline]
            pub fn cst(&mut self) -> _CSTW {
                _CSTW { w: self }
            }
            #[doc = "Bit 27 - IEEE 802"]
            #[inline]
            pub fn twokpen(&mut self) -> _TWOKPENW {
                _TWOKPENW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Frame Filter"]
    pub struct FRAMEFLTR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Frame Filter"]
    pub mod framefltr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FRAMEFLTR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PRR {
            bits: bool,
        }
        impl PRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HUCR {
            bits: bool,
        }
        impl HUCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HMCR {
            bits: bool,
        }
        impl HMCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DAIFR {
            bits: bool,
        }
        impl DAIFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMR {
            bits: bool,
        }
        impl PMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DBFR {
            bits: bool,
        }
        impl DBFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PCF`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PCFR {
            #[doc = "The MAC filters all control frames from reaching application"]
            ALL,
            #[doc = "MAC forwards all control frames except PAUSE control frames to application even if they fail the address filter"]
            PAUSE,
            #[doc = "MAC forwards all control frames to application even if they fail the address Filter"]
            NONE,
            #[doc = "MAC forwards control frames that pass the address Filter"]
            ADDR,
        }
        impl PCFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PCFR::ALL => 0,
                    PCFR::PAUSE => 0x01,
                    PCFR::NONE => 0x02,
                    PCFR::ADDR => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PCFR {
                match value {
                    0 => PCFR::ALL,
                    1 => PCFR::PAUSE,
                    2 => PCFR::NONE,
                    3 => PCFR::ADDR,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `ALL`"]
            #[inline]
            pub fn is_all(&self) -> bool {
                *self == PCFR::ALL
            }
            #[doc = "Checks if the value of the field is `PAUSE`"]
            #[inline]
            pub fn is_pause(&self) -> bool {
                *self == PCFR::PAUSE
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == PCFR::NONE
            }
            #[doc = "Checks if the value of the field is `ADDR`"]
            #[inline]
            pub fn is_addr(&self) -> bool {
                *self == PCFR::ADDR
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAIFR {
            bits: bool,
        }
        impl SAIFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAFR {
            bits: bool,
        }
        impl SAFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HPFR {
            bits: bool,
        }
        impl HPFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VTFER {
            bits: bool,
        }
        impl VTFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RAR {
            bits: bool,
        }
        impl RAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PRW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _HUCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HUCW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HMCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HMCW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DAIFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DAIFW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DBFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DBFW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PCF`"]
        pub enum PCFW {
            #[doc = "The MAC filters all control frames from reaching application"]
            ALL,
            #[doc = "MAC forwards all control frames except PAUSE control frames to application even if they fail the address filter"]
            PAUSE,
            #[doc = "MAC forwards all control frames to application even if they fail the address Filter"]
            NONE,
            #[doc = "MAC forwards control frames that pass the address Filter"]
            ADDR,
        }
        impl PCFW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PCFW::ALL => 0,
                    PCFW::PAUSE => 1,
                    PCFW::NONE => 2,
                    PCFW::ADDR => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PCFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PCFW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PCFW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "The MAC filters all control frames from reaching application"]
            #[inline]
            pub fn all(self) -> &'a mut W {
                self.variant(PCFW::ALL)
            }
            #[doc = "MAC forwards all control frames except PAUSE control frames to application even if they fail the address filter"]
            #[inline]
            pub fn pause(self) -> &'a mut W {
                self.variant(PCFW::PAUSE)
            }
            #[doc = "MAC forwards all control frames to application even if they fail the address Filter"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(PCFW::NONE)
            }
            #[doc = "MAC forwards control frames that pass the address Filter"]
            #[inline]
            pub fn addr(self) -> &'a mut W {
                self.variant(PCFW::ADDR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAIFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAIFW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAFW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HPFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HPFW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VTFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VTFEW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RAW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Promiscuous Mode"]
            #[inline]
            pub fn pr(&self) -> PRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PRR { bits }
            }
            #[doc = "Bit 1 - Hash Unicast"]
            #[inline]
            pub fn huc(&self) -> HUCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HUCR { bits }
            }
            #[doc = "Bit 2 - Hash Multicast"]
            #[inline]
            pub fn hmc(&self) -> HMCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HMCR { bits }
            }
            #[doc = "Bit 3 - Destination Address (DA) Inverse Filtering"]
            #[inline]
            pub fn daif(&self) -> DAIFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DAIFR { bits }
            }
            #[doc = "Bit 4 - Pass All Multicast"]
            #[inline]
            pub fn pm(&self) -> PMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMR { bits }
            }
            #[doc = "Bit 5 - Disable Broadcast Frames"]
            #[inline]
            pub fn dbf(&self) -> DBFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DBFR { bits }
            }
            #[doc = "Bits 6:7 - Pass Control Frames"]
            #[inline]
            pub fn pcf(&self) -> PCFR {
                PCFR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 8 - Source Address (SA) Inverse Filtering"]
            #[inline]
            pub fn saif(&self) -> SAIFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SAIFR { bits }
            }
            #[doc = "Bit 9 - Source Address Filter Enable"]
            #[inline]
            pub fn saf(&self) -> SAFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SAFR { bits }
            }
            #[doc = "Bit 10 - Hash or Perfect Filter"]
            #[inline]
            pub fn hpf(&self) -> HPFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HPFR { bits }
            }
            #[doc = "Bit 16 - VLAN Tag Filter Enable"]
            #[inline]
            pub fn vtfe(&self) -> VTFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VTFER { bits }
            }
            #[doc = "Bit 31 - Receive All"]
            #[inline]
            pub fn ra(&self) -> RAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RAR { bits }
            }
        }
        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 = "Bit 0 - Promiscuous Mode"]
            #[inline]
            pub fn pr(&mut self) -> _PRW {
                _PRW { w: self }
            }
            #[doc = "Bit 1 - Hash Unicast"]
            #[inline]
            pub fn huc(&mut self) -> _HUCW {
                _HUCW { w: self }
            }
            #[doc = "Bit 2 - Hash Multicast"]
            #[inline]
            pub fn hmc(&mut self) -> _HMCW {
                _HMCW { w: self }
            }
            #[doc = "Bit 3 - Destination Address (DA) Inverse Filtering"]
            #[inline]
            pub fn daif(&mut self) -> _DAIFW {
                _DAIFW { w: self }
            }
            #[doc = "Bit 4 - Pass All Multicast"]
            #[inline]
            pub fn pm(&mut self) -> _PMW {
                _PMW { w: self }
            }
            #[doc = "Bit 5 - Disable Broadcast Frames"]
            #[inline]
            pub fn dbf(&mut self) -> _DBFW {
                _DBFW { w: self }
            }
            #[doc = "Bits 6:7 - Pass Control Frames"]
            #[inline]
            pub fn pcf(&mut self) -> _PCFW {
                _PCFW { w: self }
            }
            #[doc = "Bit 8 - Source Address (SA) Inverse Filtering"]
            #[inline]
            pub fn saif(&mut self) -> _SAIFW {
                _SAIFW { w: self }
            }
            #[doc = "Bit 9 - Source Address Filter Enable"]
            #[inline]
            pub fn saf(&mut self) -> _SAFW {
                _SAFW { w: self }
            }
            #[doc = "Bit 10 - Hash or Perfect Filter"]
            #[inline]
            pub fn hpf(&mut self) -> _HPFW {
                _HPFW { w: self }
            }
            #[doc = "Bit 16 - VLAN Tag Filter Enable"]
            #[inline]
            pub fn vtfe(&mut self) -> _VTFEW {
                _VTFEW { w: self }
            }
            #[doc = "Bit 31 - Receive All"]
            #[inline]
            pub fn ra(&mut self) -> _RAW {
                _RAW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Hash Table High"]
    pub struct HASHTBLH {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Hash Table High"]
    pub mod hashtblh {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HASHTBLH {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HTHR {
            bits: u32,
        }
        impl HTHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HTHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HTHW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Hash Table High"]
            #[inline]
            pub fn hth(&self) -> HTHR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HTHR { bits }
            }
        }
        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 0:31 - Hash Table High"]
            #[inline]
            pub fn hth(&mut self) -> _HTHW {
                _HTHW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Hash Table Low"]
    pub struct HASHTBLL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Hash Table Low"]
    pub mod hashtbll {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HASHTBLL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HTLR {
            bits: u32,
        }
        impl HTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HTLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HTLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Hash Table Low"]
            #[inline]
            pub fn htl(&self) -> HTLR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HTLR { bits }
            }
        }
        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 0:31 - Hash Table Low"]
            #[inline]
            pub fn htl(&mut self) -> _HTLW {
                _HTLW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC MII Address"]
    pub struct MIIADDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MII Address"]
    pub mod miiaddr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MIIADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MIIBR {
            bits: bool,
        }
        impl MIIBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MIIWR {
            bits: bool,
        }
        impl MIIWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `CR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CRR {
            #[doc = "The frequency of the System Clock is 60 to 100 MHz providing a MDIO clock of SYSCLK/42"]
            _60_100,
            #[doc = "The frequency of the System Clock is 100 to 150 MHz providing a MDIO clock of SYSCLK/62"]
            _100_150,
            #[doc = "The frequency of the System Clock is 20-35 MHz providing a MDIO clock of System Clock/16"]
            _20_35,
            #[doc = "The frequency of the System Clock is 35 to 60 MHz providing a MDIO clock of System Clock/26"]
            _35_60,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CRR::_60_100 => 0,
                    CRR::_100_150 => 0x01,
                    CRR::_20_35 => 0x02,
                    CRR::_35_60 => 0x03,
                    CRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CRR {
                match value {
                    0 => CRR::_60_100,
                    1 => CRR::_100_150,
                    2 => CRR::_20_35,
                    3 => CRR::_35_60,
                    i => CRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_60_100`"]
            #[inline]
            pub fn is_60_100(&self) -> bool {
                *self == CRR::_60_100
            }
            #[doc = "Checks if the value of the field is `_100_150`"]
            #[inline]
            pub fn is_100_150(&self) -> bool {
                *self == CRR::_100_150
            }
            #[doc = "Checks if the value of the field is `_20_35`"]
            #[inline]
            pub fn is_20_35(&self) -> bool {
                *self == CRR::_20_35
            }
            #[doc = "Checks if the value of the field is `_35_60`"]
            #[inline]
            pub fn is_35_60(&self) -> bool {
                *self == CRR::_35_60
            }
        }
        #[doc = r" Value of the field"]
        pub struct MIIR {
            bits: u8,
        }
        impl MIIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PLAR {
            bits: u8,
        }
        impl PLAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _MIIBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MIIBW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MIIWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MIIWW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `CR`"]
        pub enum CRW {
            #[doc = "The frequency of the System Clock is 60 to 100 MHz providing a MDIO clock of SYSCLK/42"]
            _60_100,
            #[doc = "The frequency of the System Clock is 100 to 150 MHz providing a MDIO clock of SYSCLK/62"]
            _100_150,
            #[doc = "The frequency of the System Clock is 20-35 MHz providing a MDIO clock of System Clock/16"]
            _20_35,
            #[doc = "The frequency of the System Clock is 35 to 60 MHz providing a MDIO clock of System Clock/26"]
            _35_60,
        }
        impl CRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    CRW::_60_100 => 0,
                    CRW::_100_150 => 1,
                    CRW::_20_35 => 2,
                    CRW::_35_60 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CRW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "The frequency of the System Clock is 60 to 100 MHz providing a MDIO clock of SYSCLK/42"]
            #[inline]
            pub fn _60_100(self) -> &'a mut W {
                self.variant(CRW::_60_100)
            }
            #[doc = "The frequency of the System Clock is 100 to 150 MHz providing a MDIO clock of SYSCLK/62"]
            #[inline]
            pub fn _100_150(self) -> &'a mut W {
                self.variant(CRW::_100_150)
            }
            #[doc = "The frequency of the System Clock is 20-35 MHz providing a MDIO clock of System Clock/16"]
            #[inline]
            pub fn _20_35(self) -> &'a mut W {
                self.variant(CRW::_20_35)
            }
            #[doc = "The frequency of the System Clock is 35 to 60 MHz providing a MDIO clock of System Clock/26"]
            #[inline]
            pub fn _35_60(self) -> &'a mut W {
                self.variant(CRW::_35_60)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MIIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MIIW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PLAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PLAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MII Busy"]
            #[inline]
            pub fn miib(&self) -> MIIBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MIIBR { bits }
            }
            #[doc = "Bit 1 - MII Write"]
            #[inline]
            pub fn miiw(&self) -> MIIWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MIIWR { bits }
            }
            #[doc = "Bits 2:5 - Clock Reference Frequency Selection"]
            #[inline]
            pub fn cr(&self) -> CRR {
                CRR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:10 - MII Register"]
            #[inline]
            pub fn mii(&self) -> MIIR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MIIR { bits }
            }
            #[doc = "Bits 11:15 - Physical Layer Address"]
            #[inline]
            pub fn pla(&self) -> PLAR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PLAR { bits }
            }
        }
        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 = "Bit 0 - MII Busy"]
            #[inline]
            pub fn miib(&mut self) -> _MIIBW {
                _MIIBW { w: self }
            }
            #[doc = "Bit 1 - MII Write"]
            #[inline]
            pub fn miiw(&mut self) -> _MIIWW {
                _MIIWW { w: self }
            }
            #[doc = "Bits 2:5 - Clock Reference Frequency Selection"]
            #[inline]
            pub fn cr(&mut self) -> _CRW {
                _CRW { w: self }
            }
            #[doc = "Bits 6:10 - MII Register"]
            #[inline]
            pub fn mii(&mut self) -> _MIIW {
                _MIIW { w: self }
            }
            #[doc = "Bits 11:15 - Physical Layer Address"]
            #[inline]
            pub fn pla(&mut self) -> _PLAW {
                _PLAW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC MII Data Register"]
    pub struct MIIDATA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MII Data Register"]
    pub mod miidata {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MIIDATA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u16,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - MII Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DATAR { bits }
            }
        }
        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 0:15 - MII Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Flow Control"]
    pub struct FLOWCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Flow Control"]
    pub mod flowctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FLOWCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FCBBPAR {
            bits: bool,
        }
        impl FCBBPAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TFER {
            bits: bool,
        }
        impl TFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RFER {
            bits: bool,
        }
        impl RFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UPR {
            bits: bool,
        }
        impl UPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DZQPR {
            bits: bool,
        }
        impl DZQPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTR {
            bits: u16,
        }
        impl PTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FCBBPAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FCBBPAW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TFEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RFEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UPW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DZQPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DZQPW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Flow Control Busy or Back-pressure Activate"]
            #[inline]
            pub fn fcbbpa(&self) -> FCBBPAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FCBBPAR { bits }
            }
            #[doc = "Bit 1 - Transmit Flow Control Enable"]
            #[inline]
            pub fn tfe(&self) -> TFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TFER { bits }
            }
            #[doc = "Bit 2 - Receive Flow Control Enable"]
            #[inline]
            pub fn rfe(&self) -> RFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RFER { bits }
            }
            #[doc = "Bit 3 - Unicast Pause Frame Detect"]
            #[inline]
            pub fn up(&self) -> UPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UPR { bits }
            }
            #[doc = "Bit 7 - Disable Zero-Quanta Pause"]
            #[inline]
            pub fn dzqp(&self) -> DZQPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DZQPR { bits }
            }
            #[doc = "Bits 16:31 - Pause Time"]
            #[inline]
            pub fn pt(&self) -> PTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                PTR { bits }
            }
        }
        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 = "Bit 0 - Flow Control Busy or Back-pressure Activate"]
            #[inline]
            pub fn fcbbpa(&mut self) -> _FCBBPAW {
                _FCBBPAW { w: self }
            }
            #[doc = "Bit 1 - Transmit Flow Control Enable"]
            #[inline]
            pub fn tfe(&mut self) -> _TFEW {
                _TFEW { w: self }
            }
            #[doc = "Bit 2 - Receive Flow Control Enable"]
            #[inline]
            pub fn rfe(&mut self) -> _RFEW {
                _RFEW { w: self }
            }
            #[doc = "Bit 3 - Unicast Pause Frame Detect"]
            #[inline]
            pub fn up(&mut self) -> _UPW {
                _UPW { w: self }
            }
            #[doc = "Bit 7 - Disable Zero-Quanta Pause"]
            #[inline]
            pub fn dzqp(&mut self) -> _DZQPW {
                _DZQPW { w: self }
            }
            #[doc = "Bits 16:31 - Pause Time"]
            #[inline]
            pub fn pt(&mut self) -> _PTW {
                _PTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC VLAN Tag"]
    pub struct VLANTG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC VLAN Tag"]
    pub mod vlantg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VLANTG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VLR {
            bits: u16,
        }
        impl VLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ETVR {
            bits: bool,
        }
        impl ETVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VTIMR {
            bits: bool,
        }
        impl VTIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ESVLR {
            bits: bool,
        }
        impl ESVLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VTHMR {
            bits: bool,
        }
        impl VTHMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ETVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ETVW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VTIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VTIMW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ESVLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ESVLW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VTHMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VTHMW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - VLAN Tag Identifier for Receive Frames"]
            #[inline]
            pub fn vl(&self) -> VLR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                VLR { bits }
            }
            #[doc = "Bit 16 - Enable 12-Bit VLAN Tag Comparison"]
            #[inline]
            pub fn etv(&self) -> ETVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ETVR { bits }
            }
            #[doc = "Bit 17 - VLAN Tag Inverse Match Enable"]
            #[inline]
            pub fn vtim(&self) -> VTIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VTIMR { bits }
            }
            #[doc = "Bit 18 - Enable S-VLAN"]
            #[inline]
            pub fn esvl(&self) -> ESVLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ESVLR { bits }
            }
            #[doc = "Bit 19 - VLAN Tag Hash Table Match Enable"]
            #[inline]
            pub fn vthm(&self) -> VTHMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VTHMR { bits }
            }
        }
        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 0:15 - VLAN Tag Identifier for Receive Frames"]
            #[inline]
            pub fn vl(&mut self) -> _VLW {
                _VLW { w: self }
            }
            #[doc = "Bit 16 - Enable 12-Bit VLAN Tag Comparison"]
            #[inline]
            pub fn etv(&mut self) -> _ETVW {
                _ETVW { w: self }
            }
            #[doc = "Bit 17 - VLAN Tag Inverse Match Enable"]
            #[inline]
            pub fn vtim(&mut self) -> _VTIMW {
                _VTIMW { w: self }
            }
            #[doc = "Bit 18 - Enable S-VLAN"]
            #[inline]
            pub fn esvl(&mut self) -> _ESVLW {
                _ESVLW { w: self }
            }
            #[doc = "Bit 19 - VLAN Tag Hash Table Match Enable"]
            #[inline]
            pub fn vthm(&mut self) -> _VTHMW {
                _VTHMW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Status"]
    pub struct STATUS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Status"]
    pub mod status {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::STATUS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RPER {
            bits: bool,
        }
        impl RPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RFCFCR {
            bits: u8,
        }
        impl RFCFCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RWCR {
            bits: bool,
        }
        impl RWCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `RRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RRCR {
            #[doc = "IDLE state"]
            IDLE,
            #[doc = "Reading frame data"]
            STATUS,
            #[doc = "Reading frame status (or timestamp)"]
            DATA,
            #[doc = "Flushing the frame data and status"]
            FLUSH,
        }
        impl RRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RRCR::IDLE => 0,
                    RRCR::STATUS => 0x01,
                    RRCR::DATA => 0x02,
                    RRCR::FLUSH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RRCR {
                match value {
                    0 => RRCR::IDLE,
                    1 => RRCR::STATUS,
                    2 => RRCR::DATA,
                    3 => RRCR::FLUSH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `IDLE`"]
            #[inline]
            pub fn is_idle(&self) -> bool {
                *self == RRCR::IDLE
            }
            #[doc = "Checks if the value of the field is `STATUS`"]
            #[inline]
            pub fn is_status(&self) -> bool {
                *self == RRCR::STATUS
            }
            #[doc = "Checks if the value of the field is `DATA`"]
            #[inline]
            pub fn is_data(&self) -> bool {
                *self == RRCR::DATA
            }
            #[doc = "Checks if the value of the field is `FLUSH`"]
            #[inline]
            pub fn is_flush(&self) -> bool {
                *self == RRCR::FLUSH
            }
        }
        #[doc = "Possible values of the field `RXF`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RXFR {
            #[doc = "RX FIFO Empty"]
            EMPTY,
            #[doc = "RX FIFO fill level is below the flow-control deactivate threshold"]
            BELOW,
            #[doc = "RX FIFO fill level is above the flow-control activate threshold"]
            ABOVE,
            #[doc = "RX FIFO Full"]
            FULL,
        }
        impl RXFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RXFR::EMPTY => 0,
                    RXFR::BELOW => 0x01,
                    RXFR::ABOVE => 0x02,
                    RXFR::FULL => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RXFR {
                match value {
                    0 => RXFR::EMPTY,
                    1 => RXFR::BELOW,
                    2 => RXFR::ABOVE,
                    3 => RXFR::FULL,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `EMPTY`"]
            #[inline]
            pub fn is_empty(&self) -> bool {
                *self == RXFR::EMPTY
            }
            #[doc = "Checks if the value of the field is `BELOW`"]
            #[inline]
            pub fn is_below(&self) -> bool {
                *self == RXFR::BELOW
            }
            #[doc = "Checks if the value of the field is `ABOVE`"]
            #[inline]
            pub fn is_above(&self) -> bool {
                *self == RXFR::ABOVE
            }
            #[doc = "Checks if the value of the field is `FULL`"]
            #[inline]
            pub fn is_full(&self) -> bool {
                *self == RXFR::FULL
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPER {
            bits: bool,
        }
        impl TPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TFC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TFCR {
            #[doc = "IDLE state"]
            IDLE,
            #[doc = "Waiting for status of previous frame or IFG or backoff period to be over"]
            STATUS,
            #[doc = "Generating and transmitting a PAUSE control frame (in the full-duplex mode)"]
            PAUSE,
            #[doc = "Transferring input frame for transmission"]
            INPUT,
        }
        impl TFCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TFCR::IDLE => 0,
                    TFCR::STATUS => 0x01,
                    TFCR::PAUSE => 0x02,
                    TFCR::INPUT => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TFCR {
                match value {
                    0 => TFCR::IDLE,
                    1 => TFCR::STATUS,
                    2 => TFCR::PAUSE,
                    3 => TFCR::INPUT,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `IDLE`"]
            #[inline]
            pub fn is_idle(&self) -> bool {
                *self == TFCR::IDLE
            }
            #[doc = "Checks if the value of the field is `STATUS`"]
            #[inline]
            pub fn is_status(&self) -> bool {
                *self == TFCR::STATUS
            }
            #[doc = "Checks if the value of the field is `PAUSE`"]
            #[inline]
            pub fn is_pause(&self) -> bool {
                *self == TFCR::PAUSE
            }
            #[doc = "Checks if the value of the field is `INPUT`"]
            #[inline]
            pub fn is_input(&self) -> bool {
                *self == TFCR::INPUT
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPAUSEDR {
            bits: bool,
        }
        impl TXPAUSEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TRCR {
            #[doc = "IDLE state"]
            IDLE,
            #[doc = "READ state (transferring data to MAC transmitter)"]
            READ,
            #[doc = "Waiting for TX Status from MAC transmitter"]
            WAIT,
            #[doc = "Writing the received TX Status or flushing the TX FIFO"]
            WRFLUSH,
        }
        impl TRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TRCR::IDLE => 0,
                    TRCR::READ => 0x01,
                    TRCR::WAIT => 0x02,
                    TRCR::WRFLUSH => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TRCR {
                match value {
                    0 => TRCR::IDLE,
                    1 => TRCR::READ,
                    2 => TRCR::WAIT,
                    3 => TRCR::WRFLUSH,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `IDLE`"]
            #[inline]
            pub fn is_idle(&self) -> bool {
                *self == TRCR::IDLE
            }
            #[doc = "Checks if the value of the field is `READ`"]
            #[inline]
            pub fn is_read(&self) -> bool {
                *self == TRCR::READ
            }
            #[doc = "Checks if the value of the field is `WAIT`"]
            #[inline]
            pub fn is_wait(&self) -> bool {
                *self == TRCR::WAIT
            }
            #[doc = "Checks if the value of the field is `WRFLUSH`"]
            #[inline]
            pub fn is_wrflush(&self) -> bool {
                *self == TRCR::WRFLUSH
            }
        }
        #[doc = r" Value of the field"]
        pub struct TWCR {
            bits: bool,
        }
        impl TWCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFER {
            bits: bool,
        }
        impl TXFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFFR {
            bits: bool,
        }
        impl TXFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MAC MII Receive Protocol Engine Status"]
            #[inline]
            pub fn rpe(&self) -> RPER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RPER { bits }
            }
            #[doc = "Bits 1:2 - MAC Receive Frame Controller FIFO Status"]
            #[inline]
            pub fn rfcfc(&self) -> RFCFCR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RFCFCR { bits }
            }
            #[doc = "Bit 4 - TX/RX Controller RX FIFO Write Controller Active Status"]
            #[inline]
            pub fn rwc(&self) -> RWCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RWCR { bits }
            }
            #[doc = "Bits 5:6 - TX/RX Controller Read Controller State"]
            #[inline]
            pub fn rrc(&self) -> RRCR {
                RRCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - TX/RX Controller RX FIFO Fill-level Status"]
            #[inline]
            pub fn rxf(&self) -> RXFR {
                RXFR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - MAC MII Transmit Protocol Engine Status"]
            #[inline]
            pub fn tpe(&self) -> TPER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TPER { bits }
            }
            #[doc = "Bits 17:18 - MAC Transmit Frame Controller Status"]
            #[inline]
            pub fn tfc(&self) -> TFCR {
                TFCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 19 - MAC Transmitter PAUSE"]
            #[inline]
            pub fn txpaused(&self) -> TXPAUSEDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXPAUSEDR { bits }
            }
            #[doc = "Bits 20:21 - TX/RX Controller's TX FIFO Read Controller Status"]
            #[inline]
            pub fn trc(&self) -> TRCR {
                TRCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 22 - TX/RX Controller TX FIFO Write Controller Active Status"]
            #[inline]
            pub fn twc(&self) -> TWCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TWCR { bits }
            }
            #[doc = "Bit 24 - TX/RX Controller TX FIFO Not Empty Status"]
            #[inline]
            pub fn txfe(&self) -> TXFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFER { bits }
            }
            #[doc = "Bit 25 - TX/RX Controller TX FIFO Full Status"]
            #[inline]
            pub fn txff(&self) -> TXFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXFFR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Remote Wake-Up Frame Filter"]
    pub struct RWUFF {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Remote Wake-Up Frame Filter"]
    pub mod rwuff {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RWUFF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAKEUPFILR {
            bits: u32,
        }
        impl WAKEUPFILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _WAKEUPFILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WAKEUPFILW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Remote Wake-Up Frame Filter"]
            #[inline]
            pub fn wakeupfil(&self) -> WAKEUPFILR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                WAKEUPFILR { bits }
            }
        }
        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 0:31 - Remote Wake-Up Frame Filter"]
            #[inline]
            pub fn wakeupfil(&mut self) -> _WAKEUPFILW {
                _WAKEUPFILW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC PMT Control and Status Register"]
    pub struct PMTCTLSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC PMT Control and Status Register"]
    pub mod pmtctlstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PMTCTLSTAT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWRDWNR {
            bits: bool,
        }
        impl PWRDWNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MGKPKTENR {
            bits: bool,
        }
        impl MGKPKTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WUPFRENR {
            bits: bool,
        }
        impl WUPFRENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MGKPRXR {
            bits: bool,
        }
        impl MGKPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WUPRXR {
            bits: bool,
        }
        impl WUPRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GLBLUCASTR {
            bits: bool,
        }
        impl GLBLUCASTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RWKPTRR {
            bits: u8,
        }
        impl RWKPTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct WUPFRRSTR {
            bits: bool,
        }
        impl WUPFRRSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWRDWNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWRDWNW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MGKPKTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MGKPKTENW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WUPFRENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WUPFRENW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MGKPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MGKPRXW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WUPRXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WUPRXW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GLBLUCASTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GLBLUCASTW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RWKPTRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RWKPTRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WUPFRRSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WUPFRRSTW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Power Down"]
            #[inline]
            pub fn pwrdwn(&self) -> PWRDWNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWRDWNR { bits }
            }
            #[doc = "Bit 1 - Magic Packet Enable"]
            #[inline]
            pub fn mgkpkten(&self) -> MGKPKTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MGKPKTENR { bits }
            }
            #[doc = "Bit 2 - Wake-Up Frame Enable"]
            #[inline]
            pub fn wupfren(&self) -> WUPFRENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WUPFRENR { bits }
            }
            #[doc = "Bit 5 - Magic Packet Received"]
            #[inline]
            pub fn mgkprx(&self) -> MGKPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MGKPRXR { bits }
            }
            #[doc = "Bit 6 - Wake-Up Frame Received"]
            #[inline]
            pub fn wuprx(&self) -> WUPRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WUPRXR { bits }
            }
            #[doc = "Bit 9 - Global Unicast"]
            #[inline]
            pub fn glblucast(&self) -> GLBLUCASTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GLBLUCASTR { bits }
            }
            #[doc = "Bits 24:26 - Remote Wake-Up FIFO Pointer"]
            #[inline]
            pub fn rwkptr(&self) -> RWKPTRR {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RWKPTRR { bits }
            }
            #[doc = "Bit 31 - Wake-Up Frame Filter Register Pointer Reset"]
            #[inline]
            pub fn wupfrrst(&self) -> WUPFRRSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WUPFRRSTR { bits }
            }
        }
        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 = "Bit 0 - Power Down"]
            #[inline]
            pub fn pwrdwn(&mut self) -> _PWRDWNW {
                _PWRDWNW { w: self }
            }
            #[doc = "Bit 1 - Magic Packet Enable"]
            #[inline]
            pub fn mgkpkten(&mut self) -> _MGKPKTENW {
                _MGKPKTENW { w: self }
            }
            #[doc = "Bit 2 - Wake-Up Frame Enable"]
            #[inline]
            pub fn wupfren(&mut self) -> _WUPFRENW {
                _WUPFRENW { w: self }
            }
            #[doc = "Bit 5 - Magic Packet Received"]
            #[inline]
            pub fn mgkprx(&mut self) -> _MGKPRXW {
                _MGKPRXW { w: self }
            }
            #[doc = "Bit 6 - Wake-Up Frame Received"]
            #[inline]
            pub fn wuprx(&mut self) -> _WUPRXW {
                _WUPRXW { w: self }
            }
            #[doc = "Bit 9 - Global Unicast"]
            #[inline]
            pub fn glblucast(&mut self) -> _GLBLUCASTW {
                _GLBLUCASTW { w: self }
            }
            #[doc = "Bits 24:26 - Remote Wake-Up FIFO Pointer"]
            #[inline]
            pub fn rwkptr(&mut self) -> _RWKPTRW {
                _RWKPTRW { w: self }
            }
            #[doc = "Bit 31 - Wake-Up Frame Filter Register Pointer Reset"]
            #[inline]
            pub fn wupfrrst(&mut self) -> _WUPFRRSTW {
                _WUPFRRSTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMTR {
            bits: bool,
        }
        impl PMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MMCR {
            bits: bool,
        }
        impl MMCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MMCRXR {
            bits: bool,
        }
        impl MMCRXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MMCTXR {
            bits: bool,
        }
        impl MMCTXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSR {
            bits: bool,
        }
        impl TSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 3 - PMT Interrupt Status"]
            #[inline]
            pub fn pmt(&self) -> PMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMTR { bits }
            }
            #[doc = "Bit 4 - MMC Interrupt Status"]
            #[inline]
            pub fn mmc(&self) -> MMCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MMCR { bits }
            }
            #[doc = "Bit 5 - MMC Receive Interrupt Status"]
            #[inline]
            pub fn mmcrx(&self) -> MMCRXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MMCRXR { bits }
            }
            #[doc = "Bit 6 - MMC Transmit Interrupt Status"]
            #[inline]
            pub fn mmctx(&self) -> MMCTXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MMCTXR { bits }
            }
            #[doc = "Bit 9 - Timestamp Interrupt Status"]
            #[inline]
            pub fn ts(&self) -> TSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMTR {
            bits: bool,
        }
        impl PMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSIR {
            bits: bool,
        }
        impl TSIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSIW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 3 - PMT Interrupt Mask"]
            #[inline]
            pub fn pmt(&self) -> PMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMTR { bits }
            }
            #[doc = "Bit 9 - Timestamp Interrupt Mask"]
            #[inline]
            pub fn tsi(&self) -> TSIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSIR { bits }
            }
        }
        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 = "Bit 3 - PMT Interrupt Mask"]
            #[inline]
            pub fn pmt(&mut self) -> _PMTW {
                _PMTW { w: self }
            }
            #[doc = "Bit 9 - Timestamp Interrupt Mask"]
            #[inline]
            pub fn tsi(&mut self) -> _TSIW {
                _TSIW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 0 High"]
    pub struct ADDR0H {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 0 High"]
    pub mod addr0h {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR0H {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRHIR {
            bits: u16,
        }
        impl ADDRHIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct AER {
            bits: bool,
        }
        impl AER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRHIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRHIW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - MAC Address0 [47:32]"]
            #[inline]
            pub fn addrhi(&self) -> ADDRHIR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                ADDRHIR { bits }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&self) -> AER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AER { bits }
            }
        }
        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 0:15 - MAC Address0 [47:32]"]
            #[inline]
            pub fn addrhi(&mut self) -> _ADDRHIW {
                _ADDRHIW { w: self }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&mut self) -> _AEW {
                _AEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 0 Low Register"]
    pub struct ADDR0L {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 0 Low Register"]
    pub mod addr0l {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR0L {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRLOR {
            bits: u32,
        }
        impl ADDRLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRLOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - MAC Address0 [31:0]"]
            #[inline]
            pub fn addrlo(&self) -> ADDRLOR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRLOR { bits }
            }
        }
        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 0:31 - MAC Address0 [31:0]"]
            #[inline]
            pub fn addrlo(&mut self) -> _ADDRLOW {
                _ADDRLOW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 1 High"]
    pub struct ADDR1H {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 1 High"]
    pub mod addr1h {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR1H {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRHIR {
            bits: u16,
        }
        impl ADDRHIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MBCR {
            bits: u8,
        }
        impl MBCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAR {
            bits: bool,
        }
        impl SAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AER {
            bits: bool,
        }
        impl AER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRHIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRHIW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MBCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MBCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - MAC Address1 [47:32]"]
            #[inline]
            pub fn addrhi(&self) -> ADDRHIR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                ADDRHIR { bits }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&self) -> MBCR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MBCR { bits }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&self) -> SAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SAR { bits }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&self) -> AER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AER { bits }
            }
        }
        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 0:15 - MAC Address1 [47:32]"]
            #[inline]
            pub fn addrhi(&mut self) -> _ADDRHIW {
                _ADDRHIW { w: self }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&mut self) -> _MBCW {
                _MBCW { w: self }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&mut self) -> _SAW {
                _SAW { w: self }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&mut self) -> _AEW {
                _AEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 1 Low"]
    pub struct ADDR1L {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 1 Low"]
    pub mod addr1l {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR1L {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRLOR {
            bits: u32,
        }
        impl ADDRLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRLOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - MAC Address1 [31:0]"]
            #[inline]
            pub fn addrlo(&self) -> ADDRLOR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRLOR { bits }
            }
        }
        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 0:31 - MAC Address1 [31:0]"]
            #[inline]
            pub fn addrlo(&mut self) -> _ADDRLOW {
                _ADDRLOW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 2 High"]
    pub struct ADDR2H {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 2 High"]
    pub mod addr2h {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR2H {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRHIR {
            bits: u16,
        }
        impl ADDRHIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MBCR {
            bits: u8,
        }
        impl MBCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAR {
            bits: bool,
        }
        impl SAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AER {
            bits: bool,
        }
        impl AER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRHIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRHIW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MBCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MBCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - MAC Address2 [47:32]"]
            #[inline]
            pub fn addrhi(&self) -> ADDRHIR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                ADDRHIR { bits }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&self) -> MBCR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MBCR { bits }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&self) -> SAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SAR { bits }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&self) -> AER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AER { bits }
            }
        }
        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 0:15 - MAC Address2 [47:32]"]
            #[inline]
            pub fn addrhi(&mut self) -> _ADDRHIW {
                _ADDRHIW { w: self }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&mut self) -> _MBCW {
                _MBCW { w: self }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&mut self) -> _SAW {
                _SAW { w: self }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&mut self) -> _AEW {
                _AEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 2 Low"]
    pub struct ADDR2L {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 2 Low"]
    pub mod addr2l {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR2L {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRLOR {
            bits: u32,
        }
        impl ADDRLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRLOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - MAC Address2 [31:0]"]
            #[inline]
            pub fn addrlo(&self) -> ADDRLOR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRLOR { bits }
            }
        }
        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 0:31 - MAC Address2 [31:0]"]
            #[inline]
            pub fn addrlo(&mut self) -> _ADDRLOW {
                _ADDRLOW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 3 High"]
    pub struct ADDR3H {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 3 High"]
    pub mod addr3h {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR3H {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRHIR {
            bits: u16,
        }
        impl ADDRHIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MBCR {
            bits: u8,
        }
        impl MBCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct SAR {
            bits: bool,
        }
        impl SAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AER {
            bits: bool,
        }
        impl AER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRHIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRHIW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MBCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MBCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SAW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AEW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - MAC Address3 [47:32]"]
            #[inline]
            pub fn addrhi(&self) -> ADDRHIR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                ADDRHIR { bits }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&self) -> MBCR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MBCR { bits }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&self) -> SAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SAR { bits }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&self) -> AER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AER { bits }
            }
        }
        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 0:15 - MAC Address3 [47:32]"]
            #[inline]
            pub fn addrhi(&mut self) -> _ADDRHIW {
                _ADDRHIW { w: self }
            }
            #[doc = "Bits 24:29 - Mask Byte Control"]
            #[inline]
            pub fn mbc(&mut self) -> _MBCW {
                _MBCW { w: self }
            }
            #[doc = "Bit 30 - Source Address"]
            #[inline]
            pub fn sa(&mut self) -> _SAW {
                _SAW { w: self }
            }
            #[doc = "Bit 31 - Address Enable"]
            #[inline]
            pub fn ae(&mut self) -> _AEW {
                _AEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Address 3 Low"]
    pub struct ADDR3L {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Address 3 Low"]
    pub mod addr3l {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ADDR3L {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRLOR {
            bits: u32,
        }
        impl ADDRLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRLOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - MAC Address3 [31:0]"]
            #[inline]
            pub fn addrlo(&self) -> ADDRLOR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRLOR { bits }
            }
        }
        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 0:31 - MAC Address3 [31:0]"]
            #[inline]
            pub fn addrlo(&mut self) -> _ADDRLOW {
                _ADDRLOW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Watchdog Timeout"]
    pub struct WDOGTO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Watchdog Timeout"]
    pub mod wdogto {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::WDOGTO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WTOR {
            bits: u16,
        }
        impl WTOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWER {
            bits: bool,
        }
        impl PWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _WTOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WTOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x3fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWEW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:13 - Watchdog Timeout"]
            #[inline]
            pub fn wto(&self) -> WTOR {
                let bits = {
                    const MASK: u16 = 0x3fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                WTOR { bits }
            }
            #[doc = "Bit 16 - Programmable Watchdog Enable"]
            #[inline]
            pub fn pwe(&self) -> PWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWER { bits }
            }
        }
        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 0:13 - Watchdog Timeout"]
            #[inline]
            pub fn wto(&mut self) -> _WTOW {
                _WTOW { w: self }
            }
            #[doc = "Bit 16 - Programmable Watchdog Enable"]
            #[inline]
            pub fn pwe(&mut self) -> _PWEW {
                _PWEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC MMC Control"]
    pub struct MMCCTRL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MMC Control"]
    pub mod mmcctrl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MMCCTRL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTRSTR {
            bits: bool,
        }
        impl CNTRSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTSTPROR {
            bits: bool,
        }
        impl CNTSTPROR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTONRDR {
            bits: bool,
        }
        impl RSTONRDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTFREEZR {
            bits: bool,
        }
        impl CNTFREEZR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTPRSTR {
            bits: bool,
        }
        impl CNTPRSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CNTPRSTLVLR {
            bits: bool,
        }
        impl CNTPRSTLVLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UCDBCR {
            bits: bool,
        }
        impl UCDBCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTRSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTRSTW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTSTPROW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTSTPROW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSTONRDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSTONRDW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTFREEZW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTFREEZW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTPRSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTPRSTW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CNTPRSTLVLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CNTPRSTLVLW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UCDBCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UCDBCW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Counters Reset"]
            #[inline]
            pub fn cntrst(&self) -> CNTRSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CNTRSTR { bits }
            }
            #[doc = "Bit 1 - Counters Stop Rollover"]
            #[inline]
            pub fn cntstpro(&self) -> CNTSTPROR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CNTSTPROR { bits }
            }
            #[doc = "Bit 2 - Reset on Read"]
            #[inline]
            pub fn rstonrd(&self) -> RSTONRDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTONRDR { bits }
            }
            #[doc = "Bit 3 - MMC Counter Freeze"]
            #[inline]
            pub fn cntfreez(&self) -> CNTFREEZR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CNTFREEZR { bits }
            }
            #[doc = "Bit 4 - Counters Preset"]
            #[inline]
            pub fn cntprst(&self) -> CNTPRSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CNTPRSTR { bits }
            }
            #[doc = "Bit 5 - Full/Half Preset Level Value"]
            #[inline]
            pub fn cntprstlvl(&self) -> CNTPRSTLVLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CNTPRSTLVLR { bits }
            }
            #[doc = "Bit 8 - Update MMC Counters for Dropped Broadcast Frames"]
            #[inline]
            pub fn ucdbc(&self) -> UCDBCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UCDBCR { bits }
            }
        }
        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 = "Bit 0 - Counters Reset"]
            #[inline]
            pub fn cntrst(&mut self) -> _CNTRSTW {
                _CNTRSTW { w: self }
            }
            #[doc = "Bit 1 - Counters Stop Rollover"]
            #[inline]
            pub fn cntstpro(&mut self) -> _CNTSTPROW {
                _CNTSTPROW { w: self }
            }
            #[doc = "Bit 2 - Reset on Read"]
            #[inline]
            pub fn rstonrd(&mut self) -> _RSTONRDW {
                _RSTONRDW { w: self }
            }
            #[doc = "Bit 3 - MMC Counter Freeze"]
            #[inline]
            pub fn cntfreez(&mut self) -> _CNTFREEZW {
                _CNTFREEZW { w: self }
            }
            #[doc = "Bit 4 - Counters Preset"]
            #[inline]
            pub fn cntprst(&mut self) -> _CNTPRSTW {
                _CNTPRSTW { w: self }
            }
            #[doc = "Bit 5 - Full/Half Preset Level Value"]
            #[inline]
            pub fn cntprstlvl(&mut self) -> _CNTPRSTLVLW {
                _CNTPRSTLVLW { w: self }
            }
            #[doc = "Bit 8 - Update MMC Counters for Dropped Broadcast Frames"]
            #[inline]
            pub fn ucdbc(&mut self) -> _UCDBCW {
                _UCDBCW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC MMC Receive Raw Interrupt Status"]
    pub struct MMCRXRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MMC Receive Raw Interrupt Status"]
    pub mod mmcrxris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MMCRXRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct GBFR {
            bits: bool,
        }
        impl GBFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CRCERRR {
            bits: bool,
        }
        impl CRCERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALGNERRR {
            bits: bool,
        }
        impl ALGNERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UCGFR {
            bits: bool,
        }
        impl UCGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MMC Receive Good Bad Frame Counter Interrupt Status"]
            #[inline]
            pub fn gbf(&self) -> GBFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GBFR { bits }
            }
            #[doc = "Bit 5 - MMC Receive CRC Error Frame Counter Interrupt Status"]
            #[inline]
            pub fn crcerr(&self) -> CRCERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CRCERRR { bits }
            }
            #[doc = "Bit 6 - MMC Receive Alignment Error Frame Counter Interrupt Status"]
            #[inline]
            pub fn algnerr(&self) -> ALGNERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALGNERRR { bits }
            }
            #[doc = "Bit 17 - MMC Receive Unicast Good Frame Counter Interrupt Status"]
            #[inline]
            pub fn ucgf(&self) -> UCGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UCGFR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC MMC Transmit Raw Interrupt Status"]
    pub struct MMCTXRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MMC Transmit Raw Interrupt Status"]
    pub mod mmctxris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MMCTXRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct GBFR {
            bits: bool,
        }
        impl GBFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SCOLLGFR {
            bits: bool,
        }
        impl SCOLLGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MCOLLGFR {
            bits: bool,
        }
        impl MCOLLGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OCTCNTR {
            bits: bool,
        }
        impl OCTCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - MMC Transmit Good Bad Frame Counter Interrupt Status"]
            #[inline]
            pub fn gbf(&self) -> GBFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GBFR { bits }
            }
            #[doc = "Bit 14 - MMC Transmit Single Collision Good Frame Counter Interrupt Status"]
            #[inline]
            pub fn scollgf(&self) -> SCOLLGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SCOLLGFR { bits }
            }
            #[doc = "Bit 15 - MMC Transmit Multiple Collision Good Frame Counter Interrupt Status"]
            #[inline]
            pub fn mcollgf(&self) -> MCOLLGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MCOLLGFR { bits }
            }
            #[doc = "Bit 20 - Octet Counter Interrupt Status"]
            #[inline]
            pub fn octcnt(&self) -> OCTCNTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OCTCNTR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC MMC Receive Interrupt Mask"]
    pub struct MMCRXIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MMC Receive Interrupt Mask"]
    pub mod mmcrxim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MMCRXIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct GBFR {
            bits: bool,
        }
        impl GBFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CRCERRR {
            bits: bool,
        }
        impl CRCERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALGNERRR {
            bits: bool,
        }
        impl ALGNERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UCGFR {
            bits: bool,
        }
        impl UCGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _GBFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GBFW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CRCERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CRCERRW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALGNERRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALGNERRW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UCGFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UCGFW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - MMC Receive Good Bad Frame Counter Interrupt Mask"]
            #[inline]
            pub fn gbf(&self) -> GBFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GBFR { bits }
            }
            #[doc = "Bit 5 - MMC Receive CRC Error Frame Counter Interrupt Mask"]
            #[inline]
            pub fn crcerr(&self) -> CRCERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CRCERRR { bits }
            }
            #[doc = "Bit 6 - MMC Receive Alignment Error Frame Counter Interrupt Mask"]
            #[inline]
            pub fn algnerr(&self) -> ALGNERRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALGNERRR { bits }
            }
            #[doc = "Bit 17 - MMC Receive Unicast Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn ucgf(&self) -> UCGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UCGFR { bits }
            }
        }
        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 = "Bit 0 - MMC Receive Good Bad Frame Counter Interrupt Mask"]
            #[inline]
            pub fn gbf(&mut self) -> _GBFW {
                _GBFW { w: self }
            }
            #[doc = "Bit 5 - MMC Receive CRC Error Frame Counter Interrupt Mask"]
            #[inline]
            pub fn crcerr(&mut self) -> _CRCERRW {
                _CRCERRW { w: self }
            }
            #[doc = "Bit 6 - MMC Receive Alignment Error Frame Counter Interrupt Mask"]
            #[inline]
            pub fn algnerr(&mut self) -> _ALGNERRW {
                _ALGNERRW { w: self }
            }
            #[doc = "Bit 17 - MMC Receive Unicast Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn ucgf(&mut self) -> _UCGFW {
                _UCGFW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC MMC Transmit Interrupt Mask"]
    pub struct MMCTXIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC MMC Transmit Interrupt Mask"]
    pub mod mmctxim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MMCTXIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct GBFR {
            bits: bool,
        }
        impl GBFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SCOLLGFR {
            bits: bool,
        }
        impl SCOLLGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MCOLLGFR {
            bits: bool,
        }
        impl MCOLLGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OCTCNTR {
            bits: bool,
        }
        impl OCTCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _GBFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _GBFW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SCOLLGFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SCOLLGFW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MCOLLGFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MCOLLGFW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OCTCNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OCTCNTW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - MMC Transmit Good Bad Frame Counter Interrupt Mask"]
            #[inline]
            pub fn gbf(&self) -> GBFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GBFR { bits }
            }
            #[doc = "Bit 14 - MMC Transmit Single Collision Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn scollgf(&self) -> SCOLLGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SCOLLGFR { bits }
            }
            #[doc = "Bit 15 - MMC Transmit Multiple Collision Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn mcollgf(&self) -> MCOLLGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MCOLLGFR { bits }
            }
            #[doc = "Bit 20 - MMC Transmit Good Octet Counter Interrupt Mask"]
            #[inline]
            pub fn octcnt(&self) -> OCTCNTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OCTCNTR { bits }
            }
        }
        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 = "Bit 1 - MMC Transmit Good Bad Frame Counter Interrupt Mask"]
            #[inline]
            pub fn gbf(&mut self) -> _GBFW {
                _GBFW { w: self }
            }
            #[doc = "Bit 14 - MMC Transmit Single Collision Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn scollgf(&mut self) -> _SCOLLGFW {
                _SCOLLGFW { w: self }
            }
            #[doc = "Bit 15 - MMC Transmit Multiple Collision Good Frame Counter Interrupt Mask"]
            #[inline]
            pub fn mcollgf(&mut self) -> _MCOLLGFW {
                _MCOLLGFW { w: self }
            }
            #[doc = "Bit 20 - MMC Transmit Good Octet Counter Interrupt Mask"]
            #[inline]
            pub fn octcnt(&mut self) -> _OCTCNTW {
                _OCTCNTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Good and Bad Frames"]
    pub struct TXCNTGB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Good and Bad Frames"]
    pub mod txcntgb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXCNTGB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXFRMGBR {
            bits: u32,
        }
        impl TXFRMGBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of good and bad frames transmitted, exclusive of retried frames"]
            #[inline]
            pub fn txfrmgb(&self) -> TXFRMGBR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TXFRMGBR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Frames Transmitted after Single Collision"]
    pub struct TXCNTSCOL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Frames Transmitted after Single Collision"]
    pub mod txcntscol {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXCNTSCOL {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXSNGLCOLGR {
            bits: u32,
        }
        impl TXSNGLCOLGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of successfully transmitted frames after a single collision in the half-duplex mode"]
            #[inline]
            pub fn txsnglcolg(&self) -> TXSNGLCOLGR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TXSNGLCOLGR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Frames Transmitted after Multiple Collisions"]
    pub struct TXCNTMCOL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Frame Count for Frames Transmitted after Multiple Collisions"]
    pub mod txcntmcol {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXCNTMCOL {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXMULTCOLGR {
            bits: u32,
        }
        impl TXMULTCOLGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of successfully transmitted frames after multiple collisions in the half-duplex mode"]
            #[inline]
            pub fn txmultcolg(&self) -> TXMULTCOLGR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TXMULTCOLGR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Octet Count Good"]
    pub struct TXOCTCNTG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Octet Count Good"]
    pub mod txoctcntg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TXOCTCNTG {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXOCTGR {
            bits: u32,
        }
        impl TXOCTGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of bytes transmitted, exclusive of preamble, in good frames"]
            #[inline]
            pub fn txoctg(&self) -> TXOCTGR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TXOCTGR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Frame Count for Good and Bad Frames"]
    pub struct RXCNTGB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Frame Count for Good and Bad Frames"]
    pub mod rxcntgb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RXCNTGB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXFRMGBR {
            bits: u32,
        }
        impl RXFRMGBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of received good and bad frames"]
            #[inline]
            pub fn rxfrmgb(&self) -> RXFRMGBR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RXFRMGBR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Frame Count for CRC Error Frames"]
    pub struct RXCNTCRCERR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Frame Count for CRC Error Frames"]
    pub mod rxcntcrcerr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RXCNTCRCERR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXCRCERRR {
            bits: u32,
        }
        impl RXCRCERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of frames received with CRC error"]
            #[inline]
            pub fn rxcrcerr(&self) -> RXCRCERRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RXCRCERRR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Frame Count for Alignment Error Frames"]
    pub struct RXCNTALGNERR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Frame Count for Alignment Error Frames"]
    pub mod rxcntalgnerr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RXCNTALGNERR {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXALGNERRR {
            bits: u32,
        }
        impl RXALGNERRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of frames received with alignment (dribble) error"]
            #[inline]
            pub fn rxalgnerr(&self) -> RXALGNERRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RXALGNERRR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Frame Count for Good Unicast Frames"]
    pub struct RXCNTGUNI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Frame Count for Good Unicast Frames"]
    pub mod rxcntguni {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RXCNTGUNI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXUCASTGR {
            bits: u32,
        }
        impl RXUCASTGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - This field indicates the number of received good unicast frames"]
            #[inline]
            pub fn rxucastg(&self) -> RXUCASTGR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RXUCASTGR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC VLAN Tag Inclusion or Replacement"]
    pub struct VLNINCREP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC VLAN Tag Inclusion or Replacement"]
    pub mod vlnincrep {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VLNINCREP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VLTR {
            bits: u16,
        }
        impl VLTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `VLC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VLCR {
            #[doc = "No VLAN tag deletion, insertion, or replacement"]
            NONE,
            #[doc = "VLAN tag deletion"]
            TAGDEL,
            #[doc = "VLAN tag insertion"]
            TAGINS,
            #[doc = "VLAN tag replacement"]
            TAGREP,
        }
        impl VLCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VLCR::NONE => 0,
                    VLCR::TAGDEL => 0x01,
                    VLCR::TAGINS => 0x02,
                    VLCR::TAGREP => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VLCR {
                match value {
                    0 => VLCR::NONE,
                    1 => VLCR::TAGDEL,
                    2 => VLCR::TAGINS,
                    3 => VLCR::TAGREP,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == VLCR::NONE
            }
            #[doc = "Checks if the value of the field is `TAGDEL`"]
            #[inline]
            pub fn is_tagdel(&self) -> bool {
                *self == VLCR::TAGDEL
            }
            #[doc = "Checks if the value of the field is `TAGINS`"]
            #[inline]
            pub fn is_tagins(&self) -> bool {
                *self == VLCR::TAGINS
            }
            #[doc = "Checks if the value of the field is `TAGREP`"]
            #[inline]
            pub fn is_tagrep(&self) -> bool {
                *self == VLCR::TAGREP
            }
        }
        #[doc = r" Value of the field"]
        pub struct VLPR {
            bits: bool,
        }
        impl VLPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CSVLR {
            bits: bool,
        }
        impl CSVLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `VLC`"]
        pub enum VLCW {
            #[doc = "No VLAN tag deletion, insertion, or replacement"]
            NONE,
            #[doc = "VLAN tag deletion"]
            TAGDEL,
            #[doc = "VLAN tag insertion"]
            TAGINS,
            #[doc = "VLAN tag replacement"]
            TAGREP,
        }
        impl VLCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VLCW::NONE => 0,
                    VLCW::TAGDEL => 1,
                    VLCW::TAGINS => 2,
                    VLCW::TAGREP => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VLCW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No VLAN tag deletion, insertion, or replacement"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(VLCW::NONE)
            }
            #[doc = "VLAN tag deletion"]
            #[inline]
            pub fn tagdel(self) -> &'a mut W {
                self.variant(VLCW::TAGDEL)
            }
            #[doc = "VLAN tag insertion"]
            #[inline]
            pub fn tagins(self) -> &'a mut W {
                self.variant(VLCW::TAGINS)
            }
            #[doc = "VLAN tag replacement"]
            #[inline]
            pub fn tagrep(self) -> &'a mut W {
                self.variant(VLCW::TAGREP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLPW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CSVLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CSVLW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - VLAN Tag for Transmit Frames"]
            #[inline]
            pub fn vlt(&self) -> VLTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                VLTR { bits }
            }
            #[doc = "Bits 16:17 - VLAN Tag Control in Transmit Frames"]
            #[inline]
            pub fn vlc(&self) -> VLCR {
                VLCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 18 - VLAN Priority Control"]
            #[inline]
            pub fn vlp(&self) -> VLPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VLPR { bits }
            }
            #[doc = "Bit 19 - C-VLAN or S-VLAN"]
            #[inline]
            pub fn csvl(&self) -> CSVLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CSVLR { bits }
            }
        }
        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 0:15 - VLAN Tag for Transmit Frames"]
            #[inline]
            pub fn vlt(&mut self) -> _VLTW {
                _VLTW { w: self }
            }
            #[doc = "Bits 16:17 - VLAN Tag Control in Transmit Frames"]
            #[inline]
            pub fn vlc(&mut self) -> _VLCW {
                _VLCW { w: self }
            }
            #[doc = "Bit 18 - VLAN Priority Control"]
            #[inline]
            pub fn vlp(&mut self) -> _VLPW {
                _VLPW { w: self }
            }
            #[doc = "Bit 19 - C-VLAN or S-VLAN"]
            #[inline]
            pub fn csvl(&mut self) -> _CSVLW {
                _CSVLW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC VLAN Hash Table"]
    pub struct VLANHASH {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC VLAN Hash Table"]
    pub mod vlanhash {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::VLANHASH {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VLHTR {
            bits: u16,
        }
        impl VLHTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLHTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLHTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - VLAN Hash Table"]
            #[inline]
            pub fn vlht(&self) -> VLHTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                VLHTR { bits }
            }
        }
        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 0:15 - VLAN Hash Table"]
            #[inline]
            pub fn vlht(&mut self) -> _VLHTW {
                _VLHTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Timestamp Control"]
    pub struct TIMSTCTRL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Timestamp Control"]
    pub mod timstctrl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TIMSTCTRL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSENR {
            bits: bool,
        }
        impl TSENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSFCUPDTR {
            bits: bool,
        }
        impl TSFCUPDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSINITR {
            bits: bool,
        }
        impl TSINITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSUPDTR {
            bits: bool,
        }
        impl TSUPDTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTTRIGR {
            bits: bool,
        }
        impl INTTRIGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDREGUPR {
            bits: bool,
        }
        impl ADDREGUPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ALLFR {
            bits: bool,
        }
        impl ALLFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DGTLBINR {
            bits: bool,
        }
        impl DGTLBINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPVER2R {
            bits: bool,
        }
        impl PTPVER2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPETHR {
            bits: bool,
        }
        impl PTPETHR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPIPV6R {
            bits: bool,
        }
        impl PTPIPV6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPIPV4R {
            bits: bool,
        }
        impl PTPIPV4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSEVNTR {
            bits: bool,
        }
        impl TSEVNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSMASTR {
            bits: bool,
        }
        impl TSMASTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SELPTPR {
            bits: u8,
        }
        impl SELPTPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPFLTRR {
            bits: bool,
        }
        impl PTPFLTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSFCUPDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSFCUPDTW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSINITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSINITW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSUPDTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSUPDTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTTRIGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTTRIGW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDREGUPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDREGUPW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALLFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALLFW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DGTLBINW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DGTLBINW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTPVER2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTPVER2W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTPETHW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTPETHW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTPIPV6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTPIPV6W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTPIPV4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTPIPV4W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSEVNTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSEVNTW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSMASTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSMASTW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SELPTPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SELPTPW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PTPFLTRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PTPFLTRW<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Timestamp Enable"]
            #[inline]
            pub fn tsen(&self) -> TSENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSENR { bits }
            }
            #[doc = "Bit 1 - Timestamp Fine or Coarse Update"]
            #[inline]
            pub fn tsfcupdt(&self) -> TSFCUPDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSFCUPDTR { bits }
            }
            #[doc = "Bit 2 - Timestamp Initialize"]
            #[inline]
            pub fn tsinit(&self) -> TSINITR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSINITR { bits }
            }
            #[doc = "Bit 3 - Timestamp Update"]
            #[inline]
            pub fn tsupdt(&self) -> TSUPDTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSUPDTR { bits }
            }
            #[doc = "Bit 4 - Timestamp Interrupt Trigger Enable"]
            #[inline]
            pub fn inttrig(&self) -> INTTRIGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTTRIGR { bits }
            }
            #[doc = "Bit 5 - Addend Register Update"]
            #[inline]
            pub fn addregup(&self) -> ADDREGUPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADDREGUPR { bits }
            }
            #[doc = "Bit 8 - Enable Timestamp For All Frames"]
            #[inline]
            pub fn allf(&self) -> ALLFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ALLFR { bits }
            }
            #[doc = "Bit 9 - Timestamp Digital or Binary Rollover Control"]
            #[inline]
            pub fn dgtlbin(&self) -> DGTLBINR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DGTLBINR { bits }
            }
            #[doc = "Bit 10 - Enable PTP Packet Processing For Version 2 Format"]
            #[inline]
            pub fn ptpver2(&self) -> PTPVER2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPVER2R { bits }
            }
            #[doc = "Bit 11 - Enable Processing of PTP Over Ethernet Frames"]
            #[inline]
            pub fn ptpeth(&self) -> PTPETHR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPETHR { bits }
            }
            #[doc = "Bit 12 - Enable Processing of PTP Frames Sent Over IPv6-UDP"]
            #[inline]
            pub fn ptpipv6(&self) -> PTPIPV6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPIPV6R { bits }
            }
            #[doc = "Bit 13 - Enable Processing of PTP Frames Sent over IPv4-UDP"]
            #[inline]
            pub fn ptpipv4(&self) -> PTPIPV4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPIPV4R { bits }
            }
            #[doc = "Bit 14 - Enable Timestamp Snapshot for Event Messages"]
            #[inline]
            pub fn tsevnt(&self) -> TSEVNTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSEVNTR { bits }
            }
            #[doc = "Bit 15 - Enable Snapshot for Messages Relevant to Master"]
            #[inline]
            pub fn tsmast(&self) -> TSMASTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSMASTR { bits }
            }
            #[doc = "Bits 16:17 - Select PTP packets for Taking Snapshots"]
            #[inline]
            pub fn selptp(&self) -> SELPTPR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SELPTPR { bits }
            }
            #[doc = "Bit 18 - Enable MAC address for PTP Frame Filtering"]
            #[inline]
            pub fn ptpfltr(&self) -> PTPFLTRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPFLTRR { bits }
            }
        }
        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 = "Bit 0 - Timestamp Enable"]
            #[inline]
            pub fn tsen(&mut self) -> _TSENW {
                _TSENW { w: self }
            }
            #[doc = "Bit 1 - Timestamp Fine or Coarse Update"]
            #[inline]
            pub fn tsfcupdt(&mut self) -> _TSFCUPDTW {
                _TSFCUPDTW { w: self }
            }
            #[doc = "Bit 2 - Timestamp Initialize"]
            #[inline]
            pub fn tsinit(&mut self) -> _TSINITW {
                _TSINITW { w: self }
            }
            #[doc = "Bit 3 - Timestamp Update"]
            #[inline]
            pub fn tsupdt(&mut self) -> _TSUPDTW {
                _TSUPDTW { w: self }
            }
            #[doc = "Bit 4 - Timestamp Interrupt Trigger Enable"]
            #[inline]
            pub fn inttrig(&mut self) -> _INTTRIGW {
                _INTTRIGW { w: self }
            }
            #[doc = "Bit 5 - Addend Register Update"]
            #[inline]
            pub fn addregup(&mut self) -> _ADDREGUPW {
                _ADDREGUPW { w: self }
            }
            #[doc = "Bit 8 - Enable Timestamp For All Frames"]
            #[inline]
            pub fn allf(&mut self) -> _ALLFW {
                _ALLFW { w: self }
            }
            #[doc = "Bit 9 - Timestamp Digital or Binary Rollover Control"]
            #[inline]
            pub fn dgtlbin(&mut self) -> _DGTLBINW {
                _DGTLBINW { w: self }
            }
            #[doc = "Bit 10 - Enable PTP Packet Processing For Version 2 Format"]
            #[inline]
            pub fn ptpver2(&mut self) -> _PTPVER2W {
                _PTPVER2W { w: self }
            }
            #[doc = "Bit 11 - Enable Processing of PTP Over Ethernet Frames"]
            #[inline]
            pub fn ptpeth(&mut self) -> _PTPETHW {
                _PTPETHW { w: self }
            }
            #[doc = "Bit 12 - Enable Processing of PTP Frames Sent Over IPv6-UDP"]
            #[inline]
            pub fn ptpipv6(&mut self) -> _PTPIPV6W {
                _PTPIPV6W { w: self }
            }
            #[doc = "Bit 13 - Enable Processing of PTP Frames Sent over IPv4-UDP"]
            #[inline]
            pub fn ptpipv4(&mut self) -> _PTPIPV4W {
                _PTPIPV4W { w: self }
            }
            #[doc = "Bit 14 - Enable Timestamp Snapshot for Event Messages"]
            #[inline]
            pub fn tsevnt(&mut self) -> _TSEVNTW {
                _TSEVNTW { w: self }
            }
            #[doc = "Bit 15 - Enable Snapshot for Messages Relevant to Master"]
            #[inline]
            pub fn tsmast(&mut self) -> _TSMASTW {
                _TSMASTW { w: self }
            }
            #[doc = "Bits 16:17 - Select PTP packets for Taking Snapshots"]
            #[inline]
            pub fn selptp(&mut self) -> _SELPTPW {
                _SELPTPW { w: self }
            }
            #[doc = "Bit 18 - Enable MAC address for PTP Frame Filtering"]
            #[inline]
            pub fn ptpfltr(&mut self) -> _PTPFLTRW {
                _PTPFLTRW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Sub-Second Increment"]
    pub struct SUBSECINC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Sub-Second Increment"]
    pub mod subsecinc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SUBSECINC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SSINCR {
            bits: u8,
        }
        impl SSINCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SSINCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SSINCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Sub-second Increment Value"]
            #[inline]
            pub fn ssinc(&self) -> SSINCR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SSINCR { bits }
            }
        }
        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 0:7 - Sub-second Increment Value"]
            #[inline]
            pub fn ssinc(&mut self) -> _SSINCW {
                _SSINCW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC System Time - Seconds"]
    pub struct TIMSEC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC System Time - Seconds"]
    pub mod timsec {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TIMSEC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSSR {
            bits: u32,
        }
        impl TSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Timestamp Second"]
            #[inline]
            pub fn tss(&self) -> TSSR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSSR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC System Time - Nanoseconds"]
    pub struct TIMNANO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC System Time - Nanoseconds"]
    pub mod timnano {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TIMNANO {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSSSR {
            bits: u32,
        }
        impl TSSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:30 - Timestamp Sub-Seconds"]
            #[inline]
            pub fn tsss(&self) -> TSSSR {
                let bits = {
                    const MASK: u32 = 0x7fff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSSSR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC System Time - Seconds Update"]
    pub struct TIMSECU {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC System Time - Seconds Update"]
    pub mod timsecu {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TIMSECU {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSSR {
            bits: u32,
        }
        impl TSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Timestamp Second"]
            #[inline]
            pub fn tss(&self) -> TSSR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSSR { bits }
            }
        }
        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 0:31 - Timestamp Second"]
            #[inline]
            pub fn tss(&mut self) -> _TSSW {
                _TSSW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC System Time - Nanoseconds Update"]
    pub struct TIMNANOU {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC System Time - Nanoseconds Update"]
    pub mod timnanou {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TIMNANOU {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSSSR {
            bits: u32,
        }
        impl TSSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDSUBR {
            bits: bool,
        }
        impl ADDSUBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSSSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSSSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x7fff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDSUBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDSUBW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:30 - Timestamp Sub-Second"]
            #[inline]
            pub fn tsss(&self) -> TSSSR {
                let bits = {
                    const MASK: u32 = 0x7fff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSSSR { bits }
            }
            #[doc = "Bit 31 - Add or subtract time"]
            #[inline]
            pub fn addsub(&self) -> ADDSUBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ADDSUBR { bits }
            }
        }
        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 0:30 - Timestamp Sub-Second"]
            #[inline]
            pub fn tsss(&mut self) -> _TSSSW {
                _TSSSW { w: self }
            }
            #[doc = "Bit 31 - Add or subtract time"]
            #[inline]
            pub fn addsub(&mut self) -> _ADDSUBW {
                _ADDSUBW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Timestamp Addend"]
    pub struct TIMADD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Timestamp Addend"]
    pub mod timadd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TIMADD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSARR {
            bits: u32,
        }
        impl TSARR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSARW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSARW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Timestamp Addend Register"]
            #[inline]
            pub fn tsar(&self) -> TSARR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSARR { bits }
            }
        }
        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 0:31 - Timestamp Addend Register"]
            #[inline]
            pub fn tsar(&mut self) -> _TSARW {
                _TSARW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Target Time Seconds"]
    pub struct TARGSEC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Target Time Seconds"]
    pub mod targsec {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TARGSEC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSTRR {
            bits: u32,
        }
        impl TSTRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSTRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSTRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Target Time Seconds Register"]
            #[inline]
            pub fn tstr(&self) -> TSTRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TSTRR { bits }
            }
        }
        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 0:31 - Target Time Seconds Register"]
            #[inline]
            pub fn tstr(&mut self) -> _TSTRW {
                _TSTRW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Target Time Nanoseconds"]
    pub struct TARGNANO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Target Time Nanoseconds"]
    pub mod targnano {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TARGNANO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TTSLOR {
            bits: u32,
        }
        impl TTSLOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRGTBUSYR {
            bits: bool,
        }
        impl TRGTBUSYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TTSLOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TTSLOW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x7fff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRGTBUSYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRGTBUSYW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:30 - Target Timestamp Low Register"]
            #[inline]
            pub fn ttslo(&self) -> TTSLOR {
                let bits = {
                    const MASK: u32 = 0x7fff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TTSLOR { bits }
            }
            #[doc = "Bit 31 - Target Time Register Busy"]
            #[inline]
            pub fn trgtbusy(&self) -> TRGTBUSYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRGTBUSYR { bits }
            }
        }
        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 0:30 - Target Timestamp Low Register"]
            #[inline]
            pub fn ttslo(&mut self) -> _TTSLOW {
                _TTSLOW { w: self }
            }
            #[doc = "Bit 31 - Target Time Register Busy"]
            #[inline]
            pub fn trgtbusy(&mut self) -> _TRGTBUSYW {
                _TRGTBUSYW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC System Time-Higher Word Seconds"]
    pub struct HWORDSEC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC System Time-Higher Word Seconds"]
    pub mod hwordsec {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HWORDSEC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSHWRR {
            bits: u16,
        }
        impl TSHWRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSHWRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSHWRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Target Timestamp Higher Word Register"]
            #[inline]
            pub fn tshwr(&self) -> TSHWRR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                TSHWRR { bits }
            }
        }
        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 0:15 - Target Timestamp Higher Word Register"]
            #[inline]
            pub fn tshwr(&mut self) -> _TSHWRW {
                _TSHWRW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Timestamp Status"]
    pub struct TIMSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Timestamp Status"]
    pub mod timstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TIMSTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSSOVFR {
            bits: bool,
        }
        impl TSSOVFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSTARGTR {
            bits: bool,
        }
        impl TSTARGTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Timestamp Seconds Overflow"]
            #[inline]
            pub fn tssovf(&self) -> TSSOVFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSSOVFR { bits }
            }
            #[doc = "Bit 1 - Timestamp Target Time Reached"]
            #[inline]
            pub fn tstargt(&self) -> TSTARGTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSTARGTR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC PPS Control"]
    pub struct PPSCTRL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC PPS Control"]
    pub mod ppsctrl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PPSCTRL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PPSCTRLR {
            bits: u8,
        }
        impl PPSCTRLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PPSEN0R {
            bits: bool,
        }
        impl PPSEN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TRGMODS0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TRGMODS0R {
            #[doc = "Indicates that the Target Time registers are programmed only for generating the interrupt event"]
            INTONLY,
            #[doc = "Indicates that the Target Time registers are programmed for generating the interrupt event and starting or stopping the generation of the EN0PPS output signal"]
            INTPPS0,
            #[doc = "Indicates that the Target Time registers are programmed only for starting or stopping the generation of the EN0PPS output signal. No interrupt is asserted"]
            PPS0ONLY,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TRGMODS0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TRGMODS0R::INTONLY => 0,
                    TRGMODS0R::INTPPS0 => 0x02,
                    TRGMODS0R::PPS0ONLY => 0x03,
                    TRGMODS0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TRGMODS0R {
                match value {
                    0 => TRGMODS0R::INTONLY,
                    2 => TRGMODS0R::INTPPS0,
                    3 => TRGMODS0R::PPS0ONLY,
                    i => TRGMODS0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `INTONLY`"]
            #[inline]
            pub fn is_intonly(&self) -> bool {
                *self == TRGMODS0R::INTONLY
            }
            #[doc = "Checks if the value of the field is `INTPPS0`"]
            #[inline]
            pub fn is_intpps0(&self) -> bool {
                *self == TRGMODS0R::INTPPS0
            }
            #[doc = "Checks if the value of the field is `PPS0ONLY`"]
            #[inline]
            pub fn is_pps0only(&self) -> bool {
                *self == TRGMODS0R::PPS0ONLY
            }
        }
        #[doc = r" Proxy"]
        pub struct _PPSCTRLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PPSCTRLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PPSEN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PPSEN0W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TRGMODS0`"]
        pub enum TRGMODS0W {
            #[doc = "Indicates that the Target Time registers are programmed only for generating the interrupt event"]
            INTONLY,
            #[doc = "Indicates that the Target Time registers are programmed for generating the interrupt event and starting or stopping the generation of the EN0PPS output signal"]
            INTPPS0,
            #[doc = "Indicates that the Target Time registers are programmed only for starting or stopping the generation of the EN0PPS output signal. No interrupt is asserted"]
            PPS0ONLY,
        }
        impl TRGMODS0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TRGMODS0W::INTONLY => 0,
                    TRGMODS0W::INTPPS0 => 2,
                    TRGMODS0W::PPS0ONLY => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRGMODS0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRGMODS0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TRGMODS0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Indicates that the Target Time registers are programmed only for generating the interrupt event"]
            #[inline]
            pub fn intonly(self) -> &'a mut W {
                self.variant(TRGMODS0W::INTONLY)
            }
            #[doc = "Indicates that the Target Time registers are programmed for generating the interrupt event and starting or stopping the generation of the EN0PPS output signal"]
            #[inline]
            pub fn intpps0(self) -> &'a mut W {
                self.variant(TRGMODS0W::INTPPS0)
            }
            #[doc = "Indicates that the Target Time registers are programmed only for starting or stopping the generation of the EN0PPS output signal. No interrupt is asserted"]
            #[inline]
            pub fn pps0only(self) -> &'a mut W {
                self.variant(TRGMODS0W::PPS0ONLY)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - EN0PPS Output Frequency Control (PPSCTRL) or Command Control (PPSCMD)"]
            #[inline]
            pub fn ppsctrl(&self) -> PPSCTRLR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PPSCTRLR { bits }
            }
            #[doc = "Bit 4 - Flexible PPS Output Mode Enable"]
            #[inline]
            pub fn ppsen0(&self) -> PPSEN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PPSEN0R { bits }
            }
            #[doc = "Bits 5:6 - Target Time Register Mode for PPS0 Output"]
            #[inline]
            pub fn trgmods0(&self) -> TRGMODS0R {
                TRGMODS0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - EN0PPS Output Frequency Control (PPSCTRL) or Command Control (PPSCMD)"]
            #[inline]
            pub fn ppsctrl(&mut self) -> _PPSCTRLW {
                _PPSCTRLW { w: self }
            }
            #[doc = "Bit 4 - Flexible PPS Output Mode Enable"]
            #[inline]
            pub fn ppsen0(&mut self) -> _PPSEN0W {
                _PPSEN0W { w: self }
            }
            #[doc = "Bits 5:6 - Target Time Register Mode for PPS0 Output"]
            #[inline]
            pub fn trgmods0(&mut self) -> _TRGMODS0W {
                _TRGMODS0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC PPS0 Interval"]
    pub struct PPS0INTVL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC PPS0 Interval"]
    pub mod pps0intvl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PPS0INTVL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PPS0INTR {
            bits: u32,
        }
        impl PPS0INTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PPS0INTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PPS0INTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - PPS0 Output Signal Interval"]
            #[inline]
            pub fn pps0int(&self) -> PPS0INTR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PPS0INTR { bits }
            }
        }
        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 0:31 - PPS0 Output Signal Interval"]
            #[inline]
            pub fn pps0int(&mut self) -> _PPS0INTW {
                _PPS0INTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC PPS0 Width"]
    pub struct PPS0WIDTH {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC PPS0 Width"]
    pub mod pps0width {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PPS0WIDTH {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Ethernet MAC DMA Bus Mode"]
    pub struct DMABUSMOD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC DMA Bus Mode"]
    pub mod dmabusmod {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMABUSMOD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SWRR {
            bits: bool,
        }
        impl SWRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DAR {
            bits: bool,
        }
        impl DAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSLR {
            bits: u8,
        }
        impl DSLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct ATDSR {
            bits: bool,
        }
        impl ATDSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PBLR {
            bits: u8,
        }
        impl PBLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PRR {
            bits: u8,
        }
        impl PRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FBR {
            bits: bool,
        }
        impl FBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RPBLR {
            bits: u8,
        }
        impl RPBLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct USPR {
            bits: bool,
        }
        impl USPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct _8XPBLR {
            bits: bool,
        }
        impl _8XPBLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AALR {
            bits: bool,
        }
        impl AALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MBR {
            bits: bool,
        }
        impl MBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXPRR {
            bits: bool,
        }
        impl TXPRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIBR {
            bits: bool,
        }
        impl RIBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SWRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SWRW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _DAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DAW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ATDSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ATDSW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PBLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PBLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                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 _PRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FBW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RPBLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RPBLW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _USPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _USPW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct __8XPBLW<'a> {
            w: &'a mut W,
        }
        impl<'a> __8XPBLW<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AALW<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MBW<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXPRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXPRW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RIBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIBW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - DMA Software Reset"]
            #[inline]
            pub fn swr(&self) -> SWRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SWRR { bits }
            }
            #[doc = "Bit 1 - DMA Arbitration Scheme"]
            #[inline]
            pub fn da(&self) -> DAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DAR { bits }
            }
            #[doc = "Bits 2:6 - Descriptor Skip Length"]
            #[inline]
            pub fn dsl(&self) -> DSLR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DSLR { bits }
            }
            #[doc = "Bit 7 - Alternate Descriptor Size"]
            #[inline]
            pub fn atds(&self) -> ATDSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ATDSR { bits }
            }
            #[doc = "Bits 8:13 - Programmable Burst Length"]
            #[inline]
            pub fn pbl(&self) -> PBLR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PBLR { bits }
            }
            #[doc = "Bits 14:15 - Priority Ratio"]
            #[inline]
            pub fn pr(&self) -> PRR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PRR { bits }
            }
            #[doc = "Bit 16 - Fixed Burst"]
            #[inline]
            pub fn fb(&self) -> FBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FBR { bits }
            }
            #[doc = "Bits 17:22 - RX DMA Programmable Burst Length (PBL)"]
            #[inline]
            pub fn rpbl(&self) -> RPBLR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RPBLR { bits }
            }
            #[doc = "Bit 23 - Use Separate Programmable Burst Length (PBL)"]
            #[inline]
            pub fn usp(&self) -> USPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                USPR { bits }
            }
            #[doc = "Bit 24 - 8 x Programmable Burst Length (PBL) Mode"]
            #[inline]
            pub fn _8xpbl(&self) -> _8XPBLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                _8XPBLR { bits }
            }
            #[doc = "Bit 25 - Address Aligned Beats"]
            #[inline]
            pub fn aal(&self) -> AALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AALR { bits }
            }
            #[doc = "Bit 26 - Mixed Burst"]
            #[inline]
            pub fn mb(&self) -> MBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MBR { bits }
            }
            #[doc = "Bit 27 - Transmit Priority"]
            #[inline]
            pub fn txpr(&self) -> TXPRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TXPRR { bits }
            }
            #[doc = "Bit 31 - Rebuild Burst"]
            #[inline]
            pub fn rib(&self) -> RIBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIBR { bits }
            }
        }
        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 = "Bit 0 - DMA Software Reset"]
            #[inline]
            pub fn swr(&mut self) -> _SWRW {
                _SWRW { w: self }
            }
            #[doc = "Bit 1 - DMA Arbitration Scheme"]
            #[inline]
            pub fn da(&mut self) -> _DAW {
                _DAW { w: self }
            }
            #[doc = "Bits 2:6 - Descriptor Skip Length"]
            #[inline]
            pub fn dsl(&mut self) -> _DSLW {
                _DSLW { w: self }
            }
            #[doc = "Bit 7 - Alternate Descriptor Size"]
            #[inline]
            pub fn atds(&mut self) -> _ATDSW {
                _ATDSW { w: self }
            }
            #[doc = "Bits 8:13 - Programmable Burst Length"]
            #[inline]
            pub fn pbl(&mut self) -> _PBLW {
                _PBLW { w: self }
            }
            #[doc = "Bits 14:15 - Priority Ratio"]
            #[inline]
            pub fn pr(&mut self) -> _PRW {
                _PRW { w: self }
            }
            #[doc = "Bit 16 - Fixed Burst"]
            #[inline]
            pub fn fb(&mut self) -> _FBW {
                _FBW { w: self }
            }
            #[doc = "Bits 17:22 - RX DMA Programmable Burst Length (PBL)"]
            #[inline]
            pub fn rpbl(&mut self) -> _RPBLW {
                _RPBLW { w: self }
            }
            #[doc = "Bit 23 - Use Separate Programmable Burst Length (PBL)"]
            #[inline]
            pub fn usp(&mut self) -> _USPW {
                _USPW { w: self }
            }
            #[doc = "Bit 24 - 8 x Programmable Burst Length (PBL) Mode"]
            #[inline]
            pub fn _8xpbl(&mut self) -> __8XPBLW {
                __8XPBLW { w: self }
            }
            #[doc = "Bit 25 - Address Aligned Beats"]
            #[inline]
            pub fn aal(&mut self) -> _AALW {
                _AALW { w: self }
            }
            #[doc = "Bit 26 - Mixed Burst"]
            #[inline]
            pub fn mb(&mut self) -> _MBW {
                _MBW { w: self }
            }
            #[doc = "Bit 27 - Transmit Priority"]
            #[inline]
            pub fn txpr(&mut self) -> _TXPRW {
                _TXPRW { w: self }
            }
            #[doc = "Bit 31 - Rebuild Burst"]
            #[inline]
            pub fn rib(&mut self) -> _RIBW {
                _RIBW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Poll Demand"]
    pub struct TXPOLLD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Poll Demand"]
    pub mod txpolld {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TXPOLLD {
            #[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 _TPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TPDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Transmit Poll Demand"]
            #[inline]
            pub fn tpd(&mut self) -> _TPDW {
                _TPDW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Poll Demand"]
    pub struct RXPOLLD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Poll Demand"]
    pub mod rxpolld {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RXPOLLD {
            #[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 _RPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RPDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Receive Poll Demand"]
            #[inline]
            pub fn rpd(&mut self) -> _RPDW {
                _RPDW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Descriptor List Address"]
    pub struct RXDLADDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Descriptor List Address"]
    pub mod rxdladdr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RXDLADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct STRXLISTR {
            bits: u32,
        }
        impl STRXLISTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _STRXLISTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STRXLISTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - Start of Receive List"]
            #[inline]
            pub fn strxlist(&self) -> STRXLISTR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                STRXLISTR { bits }
            }
        }
        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 2:31 - Start of Receive List"]
            #[inline]
            pub fn strxlist(&mut self) -> _STRXLISTW {
                _STRXLISTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Transmit Descriptor List Address"]
    pub struct TXDLADDR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Transmit Descriptor List Address"]
    pub mod txdladdr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TXDLADDR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TXDLADDRR {
            bits: u32,
        }
        impl TXDLADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TXDLADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TXDLADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x3fff_ffff;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 2:31 - Start of Transmit List Base Address"]
            #[inline]
            pub fn txdladdr(&self) -> TXDLADDRR {
                let bits = {
                    const MASK: u32 = 0x3fff_ffff;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TXDLADDRR { bits }
            }
        }
        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 2:31 - Start of Transmit List Base Address"]
            #[inline]
            pub fn txdladdr(&mut self) -> _TXDLADDRW {
                _TXDLADDRW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC DMA Interrupt Status"]
    pub struct DMARIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC DMA Interrupt Status"]
    pub mod dmaris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMARIS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIR {
            bits: bool,
        }
        impl TIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPSR {
            bits: bool,
        }
        impl TPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TUR {
            bits: bool,
        }
        impl TUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TJTR {
            bits: bool,
        }
        impl TJTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVFR {
            bits: bool,
        }
        impl OVFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNFR {
            bits: bool,
        }
        impl UNFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIR {
            bits: bool,
        }
        impl RIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RUR {
            bits: bool,
        }
        impl RUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RPSR {
            bits: bool,
        }
        impl RPSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RWTR {
            bits: bool,
        }
        impl RWTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ETIR {
            bits: bool,
        }
        impl ETIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FBIR {
            bits: bool,
        }
        impl FBIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERIR {
            bits: bool,
        }
        impl ERIR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AISR {
            bits: bool,
        }
        impl AISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NISR {
            bits: bool,
        }
        impl NISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `RS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RSR {
            #[doc = "Stopped: Reset or stop receive command issued"]
            STOP,
            #[doc = "Running: Fetching receive transfer descriptor"]
            RUNRXTD,
            #[doc = "Running: Waiting for receive packet"]
            RUNRXD,
            #[doc = "Suspended: Receive descriptor unavailable"]
            SUSPEND,
            #[doc = "Running: Closing receive descriptor"]
            RUNCRD,
            #[doc = "Writing Timestamp"]
            TSWS,
            #[doc = "Running: Transferring the receive packet data from receive buffer to host memory"]
            RUNTXD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl RSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RSR::STOP => 0,
                    RSR::RUNRXTD => 0x01,
                    RSR::RUNRXD => 0x03,
                    RSR::SUSPEND => 0x04,
                    RSR::RUNCRD => 0x05,
                    RSR::TSWS => 0x06,
                    RSR::RUNTXD => 0x07,
                    RSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RSR {
                match value {
                    0 => RSR::STOP,
                    1 => RSR::RUNRXTD,
                    3 => RSR::RUNRXD,
                    4 => RSR::SUSPEND,
                    5 => RSR::RUNCRD,
                    6 => RSR::TSWS,
                    7 => RSR::RUNTXD,
                    i => RSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `STOP`"]
            #[inline]
            pub fn is_stop(&self) -> bool {
                *self == RSR::STOP
            }
            #[doc = "Checks if the value of the field is `RUNRXTD`"]
            #[inline]
            pub fn is_runrxtd(&self) -> bool {
                *self == RSR::RUNRXTD
            }
            #[doc = "Checks if the value of the field is `RUNRXD`"]
            #[inline]
            pub fn is_runrxd(&self) -> bool {
                *self == RSR::RUNRXD
            }
            #[doc = "Checks if the value of the field is `SUSPEND`"]
            #[inline]
            pub fn is_suspend(&self) -> bool {
                *self == RSR::SUSPEND
            }
            #[doc = "Checks if the value of the field is `RUNCRD`"]
            #[inline]
            pub fn is_runcrd(&self) -> bool {
                *self == RSR::RUNCRD
            }
            #[doc = "Checks if the value of the field is `TSWS`"]
            #[inline]
            pub fn is_tsws(&self) -> bool {
                *self == RSR::TSWS
            }
            #[doc = "Checks if the value of the field is `RUNTXD`"]
            #[inline]
            pub fn is_runtxd(&self) -> bool {
                *self == RSR::RUNTXD
            }
        }
        #[doc = "Possible values of the field `TS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TSR {
            #[doc = "Stopped; Reset or Stop transmit command processed"]
            STOP,
            #[doc = "Running; Fetching transmit transfer descriptor"]
            RUNTXTD,
            #[doc = "Running; Waiting for status"]
            STATUS,
            #[doc = "Running; Reading data from host memory buffer and queuing it to transmit buffer (TX FIFO)"]
            RUNTX,
            #[doc = "Writing Timestamp"]
            TSTAMP,
            #[doc = "Suspended; Transmit descriptor unavailable or transmit buffer underflow"]
            SUSPEND,
            #[doc = "Running; Closing transmit descriptor"]
            RUNCTD,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TSR::STOP => 0,
                    TSR::RUNTXTD => 0x01,
                    TSR::STATUS => 0x02,
                    TSR::RUNTX => 0x03,
                    TSR::TSTAMP => 0x04,
                    TSR::SUSPEND => 0x06,
                    TSR::RUNCTD => 0x07,
                    TSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TSR {
                match value {
                    0 => TSR::STOP,
                    1 => TSR::RUNTXTD,
                    2 => TSR::STATUS,
                    3 => TSR::RUNTX,
                    4 => TSR::TSTAMP,
                    6 => TSR::SUSPEND,
                    7 => TSR::RUNCTD,
                    i => TSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `STOP`"]
            #[inline]
            pub fn is_stop(&self) -> bool {
                *self == TSR::STOP
            }
            #[doc = "Checks if the value of the field is `RUNTXTD`"]
            #[inline]
            pub fn is_runtxtd(&self) -> bool {
                *self == TSR::RUNTXTD
            }
            #[doc = "Checks if the value of the field is `STATUS`"]
            #[inline]
            pub fn is_status(&self) -> bool {
                *self == TSR::STATUS
            }
            #[doc = "Checks if the value of the field is `RUNTX`"]
            #[inline]
            pub fn is_runtx(&self) -> bool {
                *self == TSR::RUNTX
            }
            #[doc = "Checks if the value of the field is `TSTAMP`"]
            #[inline]
            pub fn is_tstamp(&self) -> bool {
                *self == TSR::TSTAMP
            }
            #[doc = "Checks if the value of the field is `SUSPEND`"]
            #[inline]
            pub fn is_suspend(&self) -> bool {
                *self == TSR::SUSPEND
            }
            #[doc = "Checks if the value of the field is `RUNCTD`"]
            #[inline]
            pub fn is_runctd(&self) -> bool {
                *self == TSR::RUNCTD
            }
        }
        #[doc = "Possible values of the field `AE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum AER {
            #[doc = "Error during RX DMA Write Data Transfer"]
            RXDMAWD,
            #[doc = "Error during TX DMA Read Data Transfer"]
            TXDMARD,
            #[doc = "Error during RX DMA Descriptor Write Access"]
            RXDMADW,
            #[doc = "Error during TX DMA Descriptor Write Access"]
            TXDMADW,
            #[doc = "Error during RX DMA Descriptor Read Access"]
            RXDMADR,
            #[doc = "Error during TX DMA Descriptor Read Access"]
            TXDMADR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl AER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    AER::RXDMAWD => 0,
                    AER::TXDMARD => 0x03,
                    AER::RXDMADW => 0x04,
                    AER::TXDMADW => 0x05,
                    AER::RXDMADR => 0x06,
                    AER::TXDMADR => 0x07,
                    AER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> AER {
                match value {
                    0 => AER::RXDMAWD,
                    3 => AER::TXDMARD,
                    4 => AER::RXDMADW,
                    5 => AER::TXDMADW,
                    6 => AER::RXDMADR,
                    7 => AER::TXDMADR,
                    i => AER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `RXDMAWD`"]
            #[inline]
            pub fn is_rxdmawd(&self) -> bool {
                *self == AER::RXDMAWD
            }
            #[doc = "Checks if the value of the field is `TXDMARD`"]
            #[inline]
            pub fn is_txdmard(&self) -> bool {
                *self == AER::TXDMARD
            }
            #[doc = "Checks if the value of the field is `RXDMADW`"]
            #[inline]
            pub fn is_rxdmadw(&self) -> bool {
                *self == AER::RXDMADW
            }
            #[doc = "Checks if the value of the field is `TXDMADW`"]
            #[inline]
            pub fn is_txdmadw(&self) -> bool {
                *self == AER::TXDMADW
            }
            #[doc = "Checks if the value of the field is `RXDMADR`"]
            #[inline]
            pub fn is_rxdmadr(&self) -> bool {
                *self == AER::RXDMADR
            }
            #[doc = "Checks if the value of the field is `TXDMADR`"]
            #[inline]
            pub fn is_txdmadr(&self) -> bool {
                *self == AER::TXDMADR
            }
        }
        #[doc = r" Value of the field"]
        pub struct MMCR {
            bits: bool,
        }
        impl MMCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMTR {
            bits: bool,
        }
        impl PMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TTR {
            bits: bool,
        }
        impl TTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TIW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TPSW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TUW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TJTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TJTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVFW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNFW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RUW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RPSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RPSW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RWTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RWTW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ETIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ETIW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FBIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FBIW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERIW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERIW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AISW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NISW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RS`"]
        pub enum RSW {
            #[doc = "Stopped: Reset or stop receive command issued"]
            STOP,
            #[doc = "Running: Fetching receive transfer descriptor"]
            RUNRXTD,
            #[doc = "Running: Waiting for receive packet"]
            RUNRXD,
            #[doc = "Suspended: Receive descriptor unavailable"]
            SUSPEND,
            #[doc = "Running: Closing receive descriptor"]
            RUNCRD,
            #[doc = "Writing Timestamp"]
            TSWS,
            #[doc = "Running: Transferring the receive packet data from receive buffer to host memory"]
            RUNTXD,
        }
        impl RSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RSW::STOP => 0,
                    RSW::RUNRXTD => 1,
                    RSW::RUNRXD => 3,
                    RSW::SUSPEND => 4,
                    RSW::RUNCRD => 5,
                    RSW::TSWS => 6,
                    RSW::RUNTXD => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Stopped: Reset or stop receive command issued"]
            #[inline]
            pub fn stop(self) -> &'a mut W {
                self.variant(RSW::STOP)
            }
            #[doc = "Running: Fetching receive transfer descriptor"]
            #[inline]
            pub fn runrxtd(self) -> &'a mut W {
                self.variant(RSW::RUNRXTD)
            }
            #[doc = "Running: Waiting for receive packet"]
            #[inline]
            pub fn runrxd(self) -> &'a mut W {
                self.variant(RSW::RUNRXD)
            }
            #[doc = "Suspended: Receive descriptor unavailable"]
            #[inline]
            pub fn suspend(self) -> &'a mut W {
                self.variant(RSW::SUSPEND)
            }
            #[doc = "Running: Closing receive descriptor"]
            #[inline]
            pub fn runcrd(self) -> &'a mut W {
                self.variant(RSW::RUNCRD)
            }
            #[doc = "Writing Timestamp"]
            #[inline]
            pub fn tsws(self) -> &'a mut W {
                self.variant(RSW::TSWS)
            }
            #[doc = "Running: Transferring the receive packet data from receive buffer to host memory"]
            #[inline]
            pub fn runtxd(self) -> &'a mut W {
                self.variant(RSW::RUNTXD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TS`"]
        pub enum TSW {
            #[doc = "Stopped; Reset or Stop transmit command processed"]
            STOP,
            #[doc = "Running; Fetching transmit transfer descriptor"]
            RUNTXTD,
            #[doc = "Running; Waiting for status"]
            STATUS,
            #[doc = "Running; Reading data from host memory buffer and queuing it to transmit buffer (TX FIFO)"]
            RUNTX,
            #[doc = "Writing Timestamp"]
            TSTAMP,
            #[doc = "Suspended; Transmit descriptor unavailable or transmit buffer underflow"]
            SUSPEND,
            #[doc = "Running; Closing transmit descriptor"]
            RUNCTD,
        }
        impl TSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TSW::STOP => 0,
                    TSW::RUNTXTD => 1,
                    TSW::STATUS => 2,
                    TSW::RUNTX => 3,
                    TSW::TSTAMP => 4,
                    TSW::SUSPEND => 6,
                    TSW::RUNCTD => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Stopped; Reset or Stop transmit command processed"]
            #[inline]
            pub fn stop(self) -> &'a mut W {
                self.variant(TSW::STOP)
            }
            #[doc = "Running; Fetching transmit transfer descriptor"]
            #[inline]
            pub fn runtxtd(self) -> &'a mut W {
                self.variant(TSW::RUNTXTD)
            }
            #[doc = "Running; Waiting for status"]
            #[inline]
            pub fn status(self) -> &'a mut W {
                self.variant(TSW::STATUS)
            }
            #[doc = "Running; Reading data from host memory buffer and queuing it to transmit buffer (TX FIFO)"]
            #[inline]
            pub fn runtx(self) -> &'a mut W {
                self.variant(TSW::RUNTX)
            }
            #[doc = "Writing Timestamp"]
            #[inline]
            pub fn tstamp(self) -> &'a mut W {
                self.variant(TSW::TSTAMP)
            }
            #[doc = "Suspended; Transmit descriptor unavailable or transmit buffer underflow"]
            #[inline]
            pub fn suspend(self) -> &'a mut W {
                self.variant(TSW::SUSPEND)
            }
            #[doc = "Running; Closing transmit descriptor"]
            #[inline]
            pub fn runctd(self) -> &'a mut W {
                self.variant(TSW::RUNCTD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `AE`"]
        pub enum AEW {
            #[doc = "Error during RX DMA Write Data Transfer"]
            RXDMAWD,
            #[doc = "Error during TX DMA Read Data Transfer"]
            TXDMARD,
            #[doc = "Error during RX DMA Descriptor Write Access"]
            RXDMADW,
            #[doc = "Error during TX DMA Descriptor Write Access"]
            TXDMADW,
            #[doc = "Error during RX DMA Descriptor Read Access"]
            RXDMADR,
            #[doc = "Error during TX DMA Descriptor Read Access"]
            TXDMADR,
        }
        impl AEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    AEW::RXDMAWD => 0,
                    AEW::TXDMARD => 3,
                    AEW::RXDMADW => 4,
                    AEW::TXDMADW => 5,
                    AEW::RXDMADR => 6,
                    AEW::TXDMADR => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _AEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: AEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Error during RX DMA Write Data Transfer"]
            #[inline]
            pub fn rxdmawd(self) -> &'a mut W {
                self.variant(AEW::RXDMAWD)
            }
            #[doc = "Error during TX DMA Read Data Transfer"]
            #[inline]
            pub fn txdmard(self) -> &'a mut W {
                self.variant(AEW::TXDMARD)
            }
            #[doc = "Error during RX DMA Descriptor Write Access"]
            #[inline]
            pub fn rxdmadw(self) -> &'a mut W {
                self.variant(AEW::RXDMADW)
            }
            #[doc = "Error during TX DMA Descriptor Write Access"]
            #[inline]
            pub fn txdmadw(self) -> &'a mut W {
                self.variant(AEW::TXDMADW)
            }
            #[doc = "Error during RX DMA Descriptor Read Access"]
            #[inline]
            pub fn rxdmadr(self) -> &'a mut W {
                self.variant(AEW::RXDMADR)
            }
            #[doc = "Error during TX DMA Descriptor Read Access"]
            #[inline]
            pub fn txdmadr(self) -> &'a mut W {
                self.variant(AEW::TXDMADR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MMCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MMCW<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMTW<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TTW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Interrupt"]
            #[inline]
            pub fn ti(&self) -> TIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TIR { bits }
            }
            #[doc = "Bit 1 - Transmit Process Stopped"]
            #[inline]
            pub fn tps(&self) -> TPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TPSR { bits }
            }
            #[doc = "Bit 2 - Transmit Buffer Unavailable"]
            #[inline]
            pub fn tu(&self) -> TUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TUR { bits }
            }
            #[doc = "Bit 3 - Transmit Jabber Timeout"]
            #[inline]
            pub fn tjt(&self) -> TJTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TJTR { bits }
            }
            #[doc = "Bit 4 - Receive Overflow"]
            #[inline]
            pub fn ovf(&self) -> OVFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVFR { bits }
            }
            #[doc = "Bit 5 - Transmit Underflow"]
            #[inline]
            pub fn unf(&self) -> UNFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UNFR { bits }
            }
            #[doc = "Bit 6 - Receive Interrupt"]
            #[inline]
            pub fn ri(&self) -> RIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIR { bits }
            }
            #[doc = "Bit 7 - Receive Buffer Unavailable"]
            #[inline]
            pub fn ru(&self) -> RUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RUR { bits }
            }
            #[doc = "Bit 8 - Receive Process Stopped"]
            #[inline]
            pub fn rps(&self) -> RPSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RPSR { bits }
            }
            #[doc = "Bit 9 - Receive Watchdog Timeout"]
            #[inline]
            pub fn rwt(&self) -> RWTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RWTR { bits }
            }
            #[doc = "Bit 10 - Early Transmit Interrupt"]
            #[inline]
            pub fn eti(&self) -> ETIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ETIR { bits }
            }
            #[doc = "Bit 13 - Fatal Bus Error Interrupt"]
            #[inline]
            pub fn fbi(&self) -> FBIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FBIR { bits }
            }
            #[doc = "Bit 14 - Early Receive Interrupt"]
            #[inline]
            pub fn eri(&self) -> ERIR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERIR { bits }
            }
            #[doc = "Bit 15 - Abnormal Interrupt Summary"]
            #[inline]
            pub fn ais(&self) -> AISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AISR { bits }
            }
            #[doc = "Bit 16 - Normal Interrupt Summary"]
            #[inline]
            pub fn nis(&self) -> NISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NISR { bits }
            }
            #[doc = "Bits 17:19 - Received Process State"]
            #[inline]
            pub fn rs(&self) -> RSR {
                RSR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 20:22 - Transmit Process State"]
            #[inline]
            pub fn ts(&self) -> TSR {
                TSR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 23:25 - Access Error"]
            #[inline]
            pub fn ae(&self) -> AER {
                AER::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 27 - MAC MMC Interrupt"]
            #[inline]
            pub fn mmc(&self) -> MMCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MMCR { bits }
            }
            #[doc = "Bit 28 - MAC PMT Interrupt Status"]
            #[inline]
            pub fn pmt(&self) -> PMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMTR { bits }
            }
            #[doc = "Bit 29 - Timestamp Trigger Interrupt Status"]
            #[inline]
            pub fn tt(&self) -> TTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TTR { bits }
            }
        }
        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 = "Bit 0 - Transmit Interrupt"]
            #[inline]
            pub fn ti(&mut self) -> _TIW {
                _TIW { w: self }
            }
            #[doc = "Bit 1 - Transmit Process Stopped"]
            #[inline]
            pub fn tps(&mut self) -> _TPSW {
                _TPSW { w: self }
            }
            #[doc = "Bit 2 - Transmit Buffer Unavailable"]
            #[inline]
            pub fn tu(&mut self) -> _TUW {
                _TUW { w: self }
            }
            #[doc = "Bit 3 - Transmit Jabber Timeout"]
            #[inline]
            pub fn tjt(&mut self) -> _TJTW {
                _TJTW { w: self }
            }
            #[doc = "Bit 4 - Receive Overflow"]
            #[inline]
            pub fn ovf(&mut self) -> _OVFW {
                _OVFW { w: self }
            }
            #[doc = "Bit 5 - Transmit Underflow"]
            #[inline]
            pub fn unf(&mut self) -> _UNFW {
                _UNFW { w: self }
            }
            #[doc = "Bit 6 - Receive Interrupt"]
            #[inline]
            pub fn ri(&mut self) -> _RIW {
                _RIW { w: self }
            }
            #[doc = "Bit 7 - Receive Buffer Unavailable"]
            #[inline]
            pub fn ru(&mut self) -> _RUW {
                _RUW { w: self }
            }
            #[doc = "Bit 8 - Receive Process Stopped"]
            #[inline]
            pub fn rps(&mut self) -> _RPSW {
                _RPSW { w: self }
            }
            #[doc = "Bit 9 - Receive Watchdog Timeout"]
            #[inline]
            pub fn rwt(&mut self) -> _RWTW {
                _RWTW { w: self }
            }
            #[doc = "Bit 10 - Early Transmit Interrupt"]
            #[inline]
            pub fn eti(&mut self) -> _ETIW {
                _ETIW { w: self }
            }
            #[doc = "Bit 13 - Fatal Bus Error Interrupt"]
            #[inline]
            pub fn fbi(&mut self) -> _FBIW {
                _FBIW { w: self }
            }
            #[doc = "Bit 14 - Early Receive Interrupt"]
            #[inline]
            pub fn eri(&mut self) -> _ERIW {
                _ERIW { w: self }
            }
            #[doc = "Bit 15 - Abnormal Interrupt Summary"]
            #[inline]
            pub fn ais(&mut self) -> _AISW {
                _AISW { w: self }
            }
            #[doc = "Bit 16 - Normal Interrupt Summary"]
            #[inline]
            pub fn nis(&mut self) -> _NISW {
                _NISW { w: self }
            }
            #[doc = "Bits 17:19 - Received Process State"]
            #[inline]
            pub fn rs(&mut self) -> _RSW {
                _RSW { w: self }
            }
            #[doc = "Bits 20:22 - Transmit Process State"]
            #[inline]
            pub fn ts(&mut self) -> _TSW {
                _TSW { w: self }
            }
            #[doc = "Bits 23:25 - Access Error"]
            #[inline]
            pub fn ae(&mut self) -> _AEW {
                _AEW { w: self }
            }
            #[doc = "Bit 27 - MAC MMC Interrupt"]
            #[inline]
            pub fn mmc(&mut self) -> _MMCW {
                _MMCW { w: self }
            }
            #[doc = "Bit 28 - MAC PMT Interrupt Status"]
            #[inline]
            pub fn pmt(&mut self) -> _PMTW {
                _PMTW { w: self }
            }
            #[doc = "Bit 29 - Timestamp Trigger Interrupt Status"]
            #[inline]
            pub fn tt(&mut self) -> _TTW {
                _TTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC DMA Operation Mode"]
    pub struct DMAOPMODE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC DMA Operation Mode"]
    pub mod dmaopmode {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAOPMODE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SRR {
            bits: bool,
        }
        impl SRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSFR {
            bits: bool,
        }
        impl OSFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `RTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum RTCR {
            #[doc = "64 bytes"]
            _64,
            #[doc = "32 bytes"]
            _32,
            #[doc = "96 bytes"]
            _96,
            #[doc = "128 bytes"]
            _128,
        }
        impl RTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    RTCR::_64 => 0,
                    RTCR::_32 => 0x01,
                    RTCR::_96 => 0x02,
                    RTCR::_128 => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> RTCR {
                match value {
                    0 => RTCR::_64,
                    1 => RTCR::_32,
                    2 => RTCR::_96,
                    3 => RTCR::_128,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == RTCR::_64
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == RTCR::_32
            }
            #[doc = "Checks if the value of the field is `_96`"]
            #[inline]
            pub fn is_96(&self) -> bool {
                *self == RTCR::_96
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == RTCR::_128
            }
        }
        #[doc = r" Value of the field"]
        pub struct DGFR {
            bits: bool,
        }
        impl DGFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FUFR {
            bits: bool,
        }
        impl FUFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FEFR {
            bits: bool,
        }
        impl FEFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct STR {
            bits: bool,
        }
        impl STR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `TTC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TTCR {
            #[doc = "64 bytes"]
            _64,
            #[doc = "128 bytes"]
            _128,
            #[doc = "192 bytes"]
            _192,
            #[doc = "256 bytes"]
            _256,
            #[doc = "40 bytes"]
            _40,
            #[doc = "32 bytes"]
            _32,
            #[doc = "24 bytes"]
            _24,
            #[doc = "16 bytes"]
            _16,
        }
        impl TTCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TTCR::_64 => 0,
                    TTCR::_128 => 0x01,
                    TTCR::_192 => 0x02,
                    TTCR::_256 => 0x03,
                    TTCR::_40 => 0x04,
                    TTCR::_32 => 0x05,
                    TTCR::_24 => 0x06,
                    TTCR::_16 => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TTCR {
                match value {
                    0 => TTCR::_64,
                    1 => TTCR::_128,
                    2 => TTCR::_192,
                    3 => TTCR::_256,
                    4 => TTCR::_40,
                    5 => TTCR::_32,
                    6 => TTCR::_24,
                    7 => TTCR::_16,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == TTCR::_64
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == TTCR::_128
            }
            #[doc = "Checks if the value of the field is `_192`"]
            #[inline]
            pub fn is_192(&self) -> bool {
                *self == TTCR::_192
            }
            #[doc = "Checks if the value of the field is `_256`"]
            #[inline]
            pub fn is_256(&self) -> bool {
                *self == TTCR::_256
            }
            #[doc = "Checks if the value of the field is `_40`"]
            #[inline]
            pub fn is_40(&self) -> bool {
                *self == TTCR::_40
            }
            #[doc = "Checks if the value of the field is `_32`"]
            #[inline]
            pub fn is_32(&self) -> bool {
                *self == TTCR::_32
            }
            #[doc = "Checks if the value of the field is `_24`"]
            #[inline]
            pub fn is_24(&self) -> bool {
                *self == TTCR::_24
            }
            #[doc = "Checks if the value of the field is `_16`"]
            #[inline]
            pub fn is_16(&self) -> bool {
                *self == TTCR::_16
            }
        }
        #[doc = r" Value of the field"]
        pub struct FTFR {
            bits: bool,
        }
        impl FTFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSFR {
            bits: bool,
        }
        impl TSFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DFFR {
            bits: bool,
        }
        impl DFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSFR {
            bits: bool,
        }
        impl RSFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: bool,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SRW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSFW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `RTC`"]
        pub enum RTCW {
            #[doc = "64 bytes"]
            _64,
            #[doc = "32 bytes"]
            _32,
            #[doc = "96 bytes"]
            _96,
            #[doc = "128 bytes"]
            _128,
        }
        impl RTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    RTCW::_64 => 0,
                    RTCW::_32 => 1,
                    RTCW::_96 => 2,
                    RTCW::_128 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: RTCW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "64 bytes"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(RTCW::_64)
            }
            #[doc = "32 bytes"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(RTCW::_32)
            }
            #[doc = "96 bytes"]
            #[inline]
            pub fn _96(self) -> &'a mut W {
                self.variant(RTCW::_96)
            }
            #[doc = "128 bytes"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(RTCW::_128)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DGFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DGFW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FUFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FUFW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FEFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FEFW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _STW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `TTC`"]
        pub enum TTCW {
            #[doc = "64 bytes"]
            _64,
            #[doc = "128 bytes"]
            _128,
            #[doc = "192 bytes"]
            _192,
            #[doc = "256 bytes"]
            _256,
            #[doc = "40 bytes"]
            _40,
            #[doc = "32 bytes"]
            _32,
            #[doc = "24 bytes"]
            _24,
            #[doc = "16 bytes"]
            _16,
        }
        impl TTCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TTCW::_64 => 0,
                    TTCW::_128 => 1,
                    TTCW::_192 => 2,
                    TTCW::_256 => 3,
                    TTCW::_40 => 4,
                    TTCW::_32 => 5,
                    TTCW::_24 => 6,
                    TTCW::_16 => 7,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TTCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TTCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TTCW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "64 bytes"]
            #[inline]
            pub fn _64(self) -> &'a mut W {
                self.variant(TTCW::_64)
            }
            #[doc = "128 bytes"]
            #[inline]
            pub fn _128(self) -> &'a mut W {
                self.variant(TTCW::_128)
            }
            #[doc = "192 bytes"]
            #[inline]
            pub fn _192(self) -> &'a mut W {
                self.variant(TTCW::_192)
            }
            #[doc = "256 bytes"]
            #[inline]
            pub fn _256(self) -> &'a mut W {
                self.variant(TTCW::_256)
            }
            #[doc = "40 bytes"]
            #[inline]
            pub fn _40(self) -> &'a mut W {
                self.variant(TTCW::_40)
            }
            #[doc = "32 bytes"]
            #[inline]
            pub fn _32(self) -> &'a mut W {
                self.variant(TTCW::_32)
            }
            #[doc = "24 bytes"]
            #[inline]
            pub fn _24(self) -> &'a mut W {
                self.variant(TTCW::_24)
            }
            #[doc = "16 bytes"]
            #[inline]
            pub fn _16(self) -> &'a mut W {
                self.variant(TTCW::_16)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FTFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FTFW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSFW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DFFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DFFW<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSFW<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DTW<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Start or Stop Receive"]
            #[inline]
            pub fn sr(&self) -> SRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SRR { bits }
            }
            #[doc = "Bit 2 - Operate on Second Frame"]
            #[inline]
            pub fn osf(&self) -> OSFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OSFR { bits }
            }
            #[doc = "Bits 3:4 - Receive Threshold Control"]
            #[inline]
            pub fn rtc(&self) -> RTCR {
                RTCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 5 - Drop Giant Frame Enable"]
            #[inline]
            pub fn dgf(&self) -> DGFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DGFR { bits }
            }
            #[doc = "Bit 6 - Forward Undersized Good Frames"]
            #[inline]
            pub fn fuf(&self) -> FUFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FUFR { bits }
            }
            #[doc = "Bit 7 - Forward Error Frames"]
            #[inline]
            pub fn fef(&self) -> FEFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FEFR { bits }
            }
            #[doc = "Bit 13 - Start or Stop Transmission Command"]
            #[inline]
            pub fn st(&self) -> STR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                STR { bits }
            }
            #[doc = "Bits 14:16 - Transmit Threshold Control"]
            #[inline]
            pub fn ttc(&self) -> TTCR {
                TTCR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 20 - Flush Transmit FIFO"]
            #[inline]
            pub fn ftf(&self) -> FTFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FTFR { bits }
            }
            #[doc = "Bit 21 - Transmit Store and Forward"]
            #[inline]
            pub fn tsf(&self) -> TSFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSFR { bits }
            }
            #[doc = "Bit 24 - Disable Flushing of Received Frames"]
            #[inline]
            pub fn dff(&self) -> DFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DFFR { bits }
            }
            #[doc = "Bit 25 - Receive Store and Forward"]
            #[inline]
            pub fn rsf(&self) -> RSFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSFR { bits }
            }
            #[doc = "Bit 26 - Disable Dropping of TCP/IP Checksum Error Frames"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DTR { bits }
            }
        }
        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 = "Bit 1 - Start or Stop Receive"]
            #[inline]
            pub fn sr(&mut self) -> _SRW {
                _SRW { w: self }
            }
            #[doc = "Bit 2 - Operate on Second Frame"]
            #[inline]
            pub fn osf(&mut self) -> _OSFW {
                _OSFW { w: self }
            }
            #[doc = "Bits 3:4 - Receive Threshold Control"]
            #[inline]
            pub fn rtc(&mut self) -> _RTCW {
                _RTCW { w: self }
            }
            #[doc = "Bit 5 - Drop Giant Frame Enable"]
            #[inline]
            pub fn dgf(&mut self) -> _DGFW {
                _DGFW { w: self }
            }
            #[doc = "Bit 6 - Forward Undersized Good Frames"]
            #[inline]
            pub fn fuf(&mut self) -> _FUFW {
                _FUFW { w: self }
            }
            #[doc = "Bit 7 - Forward Error Frames"]
            #[inline]
            pub fn fef(&mut self) -> _FEFW {
                _FEFW { w: self }
            }
            #[doc = "Bit 13 - Start or Stop Transmission Command"]
            #[inline]
            pub fn st(&mut self) -> _STW {
                _STW { w: self }
            }
            #[doc = "Bits 14:16 - Transmit Threshold Control"]
            #[inline]
            pub fn ttc(&mut self) -> _TTCW {
                _TTCW { w: self }
            }
            #[doc = "Bit 20 - Flush Transmit FIFO"]
            #[inline]
            pub fn ftf(&mut self) -> _FTFW {
                _FTFW { w: self }
            }
            #[doc = "Bit 21 - Transmit Store and Forward"]
            #[inline]
            pub fn tsf(&mut self) -> _TSFW {
                _TSFW { w: self }
            }
            #[doc = "Bit 24 - Disable Flushing of Received Frames"]
            #[inline]
            pub fn dff(&mut self) -> _DFFW {
                _DFFW { w: self }
            }
            #[doc = "Bit 25 - Receive Store and Forward"]
            #[inline]
            pub fn rsf(&mut self) -> _RSFW {
                _RSFW { w: self }
            }
            #[doc = "Bit 26 - Disable Dropping of TCP/IP Checksum Error Frames"]
            #[inline]
            pub fn dt(&mut self) -> _DTW {
                _DTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC DMA Interrupt Mask Register"]
    pub struct DMAIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC DMA Interrupt Mask Register"]
    pub mod dmaim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIER {
            bits: bool,
        }
        impl TIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSER {
            bits: bool,
        }
        impl TSER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TUER {
            bits: bool,
        }
        impl TUER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TJER {
            bits: bool,
        }
        impl TJER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVER {
            bits: bool,
        }
        impl OVER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UNER {
            bits: bool,
        }
        impl UNER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIER {
            bits: bool,
        }
        impl RIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RUER {
            bits: bool,
        }
        impl RUER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSER {
            bits: bool,
        }
        impl RSER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RWER {
            bits: bool,
        }
        impl RWER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ETER {
            bits: bool,
        }
        impl ETER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FBER {
            bits: bool,
        }
        impl FBER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERER {
            bits: bool,
        }
        impl ERER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct AIER {
            bits: bool,
        }
        impl AIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NIER {
            bits: bool,
        }
        impl NIER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TIEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TUEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TUEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TJEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TJEW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OVEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OVEW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UNEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UNEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIEW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RUEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RUEW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSEW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RWEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RWEW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ETEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ETEW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FBEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FBEW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EREW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EREW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AIEW<'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 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NIEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NIEW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Transmit Interrupt Enable"]
            #[inline]
            pub fn tie(&self) -> TIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TIER { bits }
            }
            #[doc = "Bit 1 - Transmit Stopped Enable"]
            #[inline]
            pub fn tse(&self) -> TSER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSER { bits }
            }
            #[doc = "Bit 2 - Transmit Buffer Unvailable Enable"]
            #[inline]
            pub fn tue(&self) -> TUER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TUER { bits }
            }
            #[doc = "Bit 3 - Transmit Jabber Timeout Enable"]
            #[inline]
            pub fn tje(&self) -> TJER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TJER { bits }
            }
            #[doc = "Bit 4 - Overflow Interrupt Enable"]
            #[inline]
            pub fn ove(&self) -> OVER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVER { bits }
            }
            #[doc = "Bit 5 - Underflow Interrupt Enable"]
            #[inline]
            pub fn une(&self) -> UNER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UNER { bits }
            }
            #[doc = "Bit 6 - Receive Interrupt Enable"]
            #[inline]
            pub fn rie(&self) -> RIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RIER { bits }
            }
            #[doc = "Bit 7 - Receive Buffer Unavailable Enable"]
            #[inline]
            pub fn rue(&self) -> RUER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RUER { bits }
            }
            #[doc = "Bit 8 - Receive Stopped Enable"]
            #[inline]
            pub fn rse(&self) -> RSER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSER { bits }
            }
            #[doc = "Bit 9 - Receive Watchdog Timeout Enable"]
            #[inline]
            pub fn rwe(&self) -> RWER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RWER { bits }
            }
            #[doc = "Bit 10 - Early Transmit Interrupt Enable"]
            #[inline]
            pub fn ete(&self) -> ETER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ETER { bits }
            }
            #[doc = "Bit 13 - Fatal Bus Error Enable"]
            #[inline]
            pub fn fbe(&self) -> FBER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FBER { bits }
            }
            #[doc = "Bit 14 - Early Receive Interrupt Enable"]
            #[inline]
            pub fn ere(&self) -> ERER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERER { bits }
            }
            #[doc = "Bit 15 - Abnormal Interrupt Summary Enable"]
            #[inline]
            pub fn aie(&self) -> AIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AIER { bits }
            }
            #[doc = "Bit 16 - Normal Interrupt Summary Enable"]
            #[inline]
            pub fn nie(&self) -> NIER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NIER { bits }
            }
        }
        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 = "Bit 0 - Transmit Interrupt Enable"]
            #[inline]
            pub fn tie(&mut self) -> _TIEW {
                _TIEW { w: self }
            }
            #[doc = "Bit 1 - Transmit Stopped Enable"]
            #[inline]
            pub fn tse(&mut self) -> _TSEW {
                _TSEW { w: self }
            }
            #[doc = "Bit 2 - Transmit Buffer Unvailable Enable"]
            #[inline]
            pub fn tue(&mut self) -> _TUEW {
                _TUEW { w: self }
            }
            #[doc = "Bit 3 - Transmit Jabber Timeout Enable"]
            #[inline]
            pub fn tje(&mut self) -> _TJEW {
                _TJEW { w: self }
            }
            #[doc = "Bit 4 - Overflow Interrupt Enable"]
            #[inline]
            pub fn ove(&mut self) -> _OVEW {
                _OVEW { w: self }
            }
            #[doc = "Bit 5 - Underflow Interrupt Enable"]
            #[inline]
            pub fn une(&mut self) -> _UNEW {
                _UNEW { w: self }
            }
            #[doc = "Bit 6 - Receive Interrupt Enable"]
            #[inline]
            pub fn rie(&mut self) -> _RIEW {
                _RIEW { w: self }
            }
            #[doc = "Bit 7 - Receive Buffer Unavailable Enable"]
            #[inline]
            pub fn rue(&mut self) -> _RUEW {
                _RUEW { w: self }
            }
            #[doc = "Bit 8 - Receive Stopped Enable"]
            #[inline]
            pub fn rse(&mut self) -> _RSEW {
                _RSEW { w: self }
            }
            #[doc = "Bit 9 - Receive Watchdog Timeout Enable"]
            #[inline]
            pub fn rwe(&mut self) -> _RWEW {
                _RWEW { w: self }
            }
            #[doc = "Bit 10 - Early Transmit Interrupt Enable"]
            #[inline]
            pub fn ete(&mut self) -> _ETEW {
                _ETEW { w: self }
            }
            #[doc = "Bit 13 - Fatal Bus Error Enable"]
            #[inline]
            pub fn fbe(&mut self) -> _FBEW {
                _FBEW { w: self }
            }
            #[doc = "Bit 14 - Early Receive Interrupt Enable"]
            #[inline]
            pub fn ere(&mut self) -> _EREW {
                _EREW { w: self }
            }
            #[doc = "Bit 15 - Abnormal Interrupt Summary Enable"]
            #[inline]
            pub fn aie(&mut self) -> _AIEW {
                _AIEW { w: self }
            }
            #[doc = "Bit 16 - Normal Interrupt Summary Enable"]
            #[inline]
            pub fn nie(&mut self) -> _NIEW {
                _NIEW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Missed Frame and Buffer Overflow Counter"]
    pub struct MFBOC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Missed Frame and Buffer Overflow Counter"]
    pub mod mfboc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MFBOC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct MISFRMCNTR {
            bits: u16,
        }
        impl MISFRMCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MISCNTOVFR {
            bits: bool,
        }
        impl MISCNTOVFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVFFRMCNTR {
            bits: u16,
        }
        impl OVFFRMCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct OVFCNTOVFR {
            bits: bool,
        }
        impl OVFCNTOVFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Missed Frame Counter"]
            #[inline]
            pub fn misfrmcnt(&self) -> MISFRMCNTR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MISFRMCNTR { bits }
            }
            #[doc = "Bit 16 - Overflow bit for Missed Frame Counter"]
            #[inline]
            pub fn miscntovf(&self) -> MISCNTOVFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MISCNTOVFR { bits }
            }
            #[doc = "Bits 17:27 - Overflow Frame Counter"]
            #[inline]
            pub fn ovffrmcnt(&self) -> OVFFRMCNTR {
                let bits = {
                    const MASK: u16 = 0x07ff;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                OVFFRMCNTR { bits }
            }
            #[doc = "Bit 28 - Overflow Bit for FIFO Overflow Counter"]
            #[inline]
            pub fn ovfcntovf(&self) -> OVFCNTOVFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OVFCNTOVFR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Receive Interrupt Watchdog Timer"]
    pub struct RXINTWDT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Receive Interrupt Watchdog Timer"]
    pub mod rxintwdt {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RXINTWDT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RIWTR {
            bits: u8,
        }
        impl RIWTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RIWTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RIWTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Receive Interrupt Watchdog Timer Count"]
            #[inline]
            pub fn riwt(&self) -> RIWTR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                RIWTR { bits }
            }
        }
        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 0:7 - Receive Interrupt Watchdog Timer Count"]
            #[inline]
            pub fn riwt(&mut self) -> _RIWTW {
                _RIWTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Current Host Transmit Descriptor"]
    pub struct HOSTXDESC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Current Host Transmit Descriptor"]
    pub mod hostxdesc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::HOSTXDESC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CURTXDESCR {
            bits: u32,
        }
        impl CURTXDESCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Host Transmit Descriptor Address Pointer"]
            #[inline]
            pub fn curtxdesc(&self) -> CURTXDESCR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CURTXDESCR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Current Host Receive Descriptor"]
    pub struct HOSRXDESC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Current Host Receive Descriptor"]
    pub mod hosrxdesc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::HOSRXDESC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CURRXDESCR {
            bits: u32,
        }
        impl CURRXDESCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Host Receive Descriptor Address Pointer"]
            #[inline]
            pub fn currxdesc(&self) -> CURRXDESCR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CURRXDESCR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Current Host Transmit Buffer Address"]
    pub struct HOSTXBA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Current Host Transmit Buffer Address"]
    pub mod hostxba {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::HOSTXBA {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CURTXBUFAR {
            bits: u32,
        }
        impl CURTXBUFAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Host Transmit Buffer Address Pointer"]
            #[inline]
            pub fn curtxbufa(&self) -> CURTXBUFAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CURTXBUFAR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Current Host Receive Buffer Address"]
    pub struct HOSRXBA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Current Host Receive Buffer Address"]
    pub mod hosrxba {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::HOSRXBA {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CURRXBUFAR {
            bits: u32,
        }
        impl CURRXBUFAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Host Receive Buffer Address Pointer"]
            #[inline]
            pub fn currxbufa(&self) -> CURRXBUFAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CURRXBUFAR { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Peripheral Property Register"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Peripheral Property Register"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `PHYTYPE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PHYTYPER {
            #[doc = "No PHY"]
            NONE,
            #[doc = "Snowflake class PHY"]
            _1,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PHYTYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PHYTYPER::NONE => 0,
                    PHYTYPER::_1 => 0x03,
                    PHYTYPER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PHYTYPER {
                match value {
                    0 => PHYTYPER::NONE,
                    3 => PHYTYPER::_1,
                    i => PHYTYPER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == PHYTYPER::NONE
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == PHYTYPER::_1
            }
        }
        #[doc = r" Value of the field"]
        pub struct MACTYPER {
            bits: u8,
        }
        impl MACTYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:2 - Ethernet PHY Type"]
            #[inline]
            pub fn phytype(&self) -> PHYTYPER {
                PHYTYPER::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:10 - Ethernet MAC Type"]
            #[inline]
            pub fn mactype(&self) -> MACTYPER {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MACTYPER { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Peripheral Configuration Register"]
    pub struct PC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Peripheral Configuration Register"]
    pub mod pc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PHYHOLDR {
            bits: bool,
        }
        impl PHYHOLDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `ANMODE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ANMODER {
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Half-Duplex"]
            _10HD,
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Full-Duplex"]
            _10FD,
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Half-Duplex"]
            _100HD,
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Full-Duplex"]
            _100FD,
        }
        impl ANMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ANMODER::_10HD => 0,
                    ANMODER::_10FD => 0x01,
                    ANMODER::_100HD => 0x02,
                    ANMODER::_100FD => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ANMODER {
                match value {
                    0 => ANMODER::_10HD,
                    1 => ANMODER::_10FD,
                    2 => ANMODER::_100HD,
                    3 => ANMODER::_100FD,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_10HD`"]
            #[inline]
            pub fn is_10hd(&self) -> bool {
                *self == ANMODER::_10HD
            }
            #[doc = "Checks if the value of the field is `_10FD`"]
            #[inline]
            pub fn is_10fd(&self) -> bool {
                *self == ANMODER::_10FD
            }
            #[doc = "Checks if the value of the field is `_100HD`"]
            #[inline]
            pub fn is_100hd(&self) -> bool {
                *self == ANMODER::_100HD
            }
            #[doc = "Checks if the value of the field is `_100FD`"]
            #[inline]
            pub fn is_100fd(&self) -> bool {
                *self == ANMODER::_100FD
            }
        }
        #[doc = r" Value of the field"]
        pub struct ANENR {
            bits: bool,
        }
        impl ANENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTANSELR {
            bits: u8,
        }
        impl FASTANSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTANENR {
            bits: bool,
        }
        impl FASTANENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTFDR {
            bits: bool,
        }
        impl EXTFDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTLUPDR {
            bits: bool,
        }
        impl FASTLUPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTRXDVR {
            bits: bool,
        }
        impl FASTRXDVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MDIXENR {
            bits: bool,
        }
        impl MDIXENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTMDIXR {
            bits: bool,
        }
        impl FASTMDIXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RBSTMDIXR {
            bits: bool,
        }
        impl RBSTMDIXR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MDISWAPR {
            bits: bool,
        }
        impl MDISWAPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct POLSWAPR {
            bits: bool,
        }
        impl POLSWAPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FASTLDMODER {
            bits: u8,
        }
        impl FASTLDMODER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct TDRRUNR {
            bits: bool,
        }
        impl TDRRUNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LRRR {
            bits: bool,
        }
        impl LRRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ISOMIILLR {
            bits: bool,
        }
        impl ISOMIILLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RXERIDLER {
            bits: bool,
        }
        impl RXERIDLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NIBDETDISR {
            bits: bool,
        }
        impl NIBDETDISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIGRESTARTR {
            bits: bool,
        }
        impl DIGRESTARTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PINTFS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PINTFSR {
            #[doc = "MII (default) Used for internal PHY or external PHY connected via MII"]
            IMII,
            #[doc = "RMII: Used for external PHY connected via RMII"]
            RMII,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PINTFSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PINTFSR::IMII => 0,
                    PINTFSR::RMII => 0x04,
                    PINTFSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PINTFSR {
                match value {
                    0 => PINTFSR::IMII,
                    4 => PINTFSR::RMII,
                    i => PINTFSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IMII`"]
            #[inline]
            pub fn is_imii(&self) -> bool {
                *self == PINTFSR::IMII
            }
            #[doc = "Checks if the value of the field is `RMII`"]
            #[inline]
            pub fn is_rmii(&self) -> bool {
                *self == PINTFSR::RMII
            }
        }
        #[doc = r" Value of the field"]
        pub struct PHYEXTR {
            bits: bool,
        }
        impl PHYEXTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PHYHOLDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PHYHOLDW<'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
            }
        }
        #[doc = "Values that can be written to the field `ANMODE`"]
        pub enum ANMODEW {
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Half-Duplex"]
            _10HD,
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Full-Duplex"]
            _10FD,
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Half-Duplex"]
            _100HD,
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Full-Duplex"]
            _100FD,
        }
        impl ANMODEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ANMODEW::_10HD => 0,
                    ANMODEW::_10FD => 1,
                    ANMODEW::_100HD => 2,
                    ANMODEW::_100FD => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ANMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ANMODEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ANMODEW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Half-Duplex"]
            #[inline]
            pub fn _10hd(self) -> &'a mut W {
                self.variant(ANMODEW::_10HD)
            }
            #[doc = "When ANEN = 0x0, the mode is 10Base-T, Full-Duplex"]
            #[inline]
            pub fn _10fd(self) -> &'a mut W {
                self.variant(ANMODEW::_10FD)
            }
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Half-Duplex"]
            #[inline]
            pub fn _100hd(self) -> &'a mut W {
                self.variant(ANMODEW::_100HD)
            }
            #[doc = "When ANEN = 0x0, the mode is 100Base-TX, Full-Duplex"]
            #[inline]
            pub fn _100fd(self) -> &'a mut W {
                self.variant(ANMODEW::_100FD)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _ANENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ANENW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTANSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTANSELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTANENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTANENW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTFDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTFDW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTLUPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTLUPDW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTRXDVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTRXDVW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MDIXENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MDIXENW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTMDIXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTMDIXW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RBSTMDIXW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RBSTMDIXW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MDISWAPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MDISWAPW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _POLSWAPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _POLSWAPW<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FASTLDMODEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FASTLDMODEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 15;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TDRRUNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TDRRUNW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LRRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LRRW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ISOMIILLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ISOMIILLW<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RXERIDLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RXERIDLEW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NIBDETDISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NIBDETDISW<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIGRESTARTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIGRESTARTW<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PINTFS`"]
        pub enum PINTFSW {
            #[doc = "MII (default) Used for internal PHY or external PHY connected via MII"]
            IMII,
            #[doc = "RMII: Used for external PHY connected via RMII"]
            RMII,
        }
        impl PINTFSW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PINTFSW::IMII => 0,
                    PINTFSW::RMII => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PINTFSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PINTFSW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PINTFSW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "MII (default) Used for internal PHY or external PHY connected via MII"]
            #[inline]
            pub fn imii(self) -> &'a mut W {
                self.variant(PINTFSW::IMII)
            }
            #[doc = "RMII: Used for external PHY connected via RMII"]
            #[inline]
            pub fn rmii(self) -> &'a mut W {
                self.variant(PINTFSW::RMII)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PHYEXTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PHYEXTW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Hold"]
            #[inline]
            pub fn phyhold(&self) -> PHYHOLDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PHYHOLDR { bits }
            }
            #[doc = "Bits 1:2 - Auto Negotiation Mode"]
            #[inline]
            pub fn anmode(&self) -> ANMODER {
                ANMODER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 3 - Auto Negotiation Enable"]
            #[inline]
            pub fn anen(&self) -> ANENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ANENR { bits }
            }
            #[doc = "Bits 4:5 - Fast Auto Negotiation Select"]
            #[inline]
            pub fn fastansel(&self) -> FASTANSELR {
                let bits = {
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FASTANSELR { bits }
            }
            #[doc = "Bit 6 - Fast Auto Negotiation Enable"]
            #[inline]
            pub fn fastanen(&self) -> FASTANENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FASTANENR { bits }
            }
            #[doc = "Bit 7 - Extended Full Duplex Ability"]
            #[inline]
            pub fn extfd(&self) -> EXTFDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTFDR { bits }
            }
            #[doc = "Bit 8 - FAST Link-Up in Parallel Detect"]
            #[inline]
            pub fn fastlupd(&self) -> FASTLUPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FASTLUPDR { bits }
            }
            #[doc = "Bit 9 - Fast RXDV Detection"]
            #[inline]
            pub fn fastrxdv(&self) -> FASTRXDVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FASTRXDVR { bits }
            }
            #[doc = "Bit 10 - MDIX Enable"]
            #[inline]
            pub fn mdixen(&self) -> MDIXENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MDIXENR { bits }
            }
            #[doc = "Bit 11 - Fast Auto MDI-X"]
            #[inline]
            pub fn fastmdix(&self) -> FASTMDIXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FASTMDIXR { bits }
            }
            #[doc = "Bit 12 - Robust Auto MDI-X"]
            #[inline]
            pub fn rbstmdix(&self) -> RBSTMDIXR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RBSTMDIXR { bits }
            }
            #[doc = "Bit 13 - MDI Swap"]
            #[inline]
            pub fn mdiswap(&self) -> MDISWAPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MDISWAPR { bits }
            }
            #[doc = "Bit 14 - Polarity Swap"]
            #[inline]
            pub fn polswap(&self) -> POLSWAPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                POLSWAPR { bits }
            }
            #[doc = "Bits 15:19 - Fast Link Down Mode"]
            #[inline]
            pub fn fastldmode(&self) -> FASTLDMODER {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 15;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FASTLDMODER { bits }
            }
            #[doc = "Bit 20 - TDR Auto Run"]
            #[inline]
            pub fn tdrrun(&self) -> TDRRUNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TDRRUNR { bits }
            }
            #[doc = "Bit 21 - Link Loss Recovery"]
            #[inline]
            pub fn lrr(&self) -> LRRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LRRR { bits }
            }
            #[doc = "Bit 22 - Isolate MII in Link Loss"]
            #[inline]
            pub fn isomiill(&self) -> ISOMIILLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ISOMIILLR { bits }
            }
            #[doc = "Bit 23 - RXER Detection During Idle"]
            #[inline]
            pub fn rxeridle(&self) -> RXERIDLER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RXERIDLER { bits }
            }
            #[doc = "Bit 24 - Odd Nibble TXER Detection Disable"]
            #[inline]
            pub fn nibdetdis(&self) -> NIBDETDISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NIBDETDISR { bits }
            }
            #[doc = "Bit 25 - PHY Soft Restart"]
            #[inline]
            pub fn digrestart(&self) -> DIGRESTARTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DIGRESTARTR { bits }
            }
            #[doc = "Bits 28:30 - Ethernet Interface Select"]
            #[inline]
            pub fn pintfs(&self) -> PINTFSR {
                PINTFSR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 31 - PHY Select"]
            #[inline]
            pub fn phyext(&self) -> PHYEXTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PHYEXTR { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Hold"]
            #[inline]
            pub fn phyhold(&mut self) -> _PHYHOLDW {
                _PHYHOLDW { w: self }
            }
            #[doc = "Bits 1:2 - Auto Negotiation Mode"]
            #[inline]
            pub fn anmode(&mut self) -> _ANMODEW {
                _ANMODEW { w: self }
            }
            #[doc = "Bit 3 - Auto Negotiation Enable"]
            #[inline]
            pub fn anen(&mut self) -> _ANENW {
                _ANENW { w: self }
            }
            #[doc = "Bits 4:5 - Fast Auto Negotiation Select"]
            #[inline]
            pub fn fastansel(&mut self) -> _FASTANSELW {
                _FASTANSELW { w: self }
            }
            #[doc = "Bit 6 - Fast Auto Negotiation Enable"]
            #[inline]
            pub fn fastanen(&mut self) -> _FASTANENW {
                _FASTANENW { w: self }
            }
            #[doc = "Bit 7 - Extended Full Duplex Ability"]
            #[inline]
            pub fn extfd(&mut self) -> _EXTFDW {
                _EXTFDW { w: self }
            }
            #[doc = "Bit 8 - FAST Link-Up in Parallel Detect"]
            #[inline]
            pub fn fastlupd(&mut self) -> _FASTLUPDW {
                _FASTLUPDW { w: self }
            }
            #[doc = "Bit 9 - Fast RXDV Detection"]
            #[inline]
            pub fn fastrxdv(&mut self) -> _FASTRXDVW {
                _FASTRXDVW { w: self }
            }
            #[doc = "Bit 10 - MDIX Enable"]
            #[inline]
            pub fn mdixen(&mut self) -> _MDIXENW {
                _MDIXENW { w: self }
            }
            #[doc = "Bit 11 - Fast Auto MDI-X"]
            #[inline]
            pub fn fastmdix(&mut self) -> _FASTMDIXW {
                _FASTMDIXW { w: self }
            }
            #[doc = "Bit 12 - Robust Auto MDI-X"]
            #[inline]
            pub fn rbstmdix(&mut self) -> _RBSTMDIXW {
                _RBSTMDIXW { w: self }
            }
            #[doc = "Bit 13 - MDI Swap"]
            #[inline]
            pub fn mdiswap(&mut self) -> _MDISWAPW {
                _MDISWAPW { w: self }
            }
            #[doc = "Bit 14 - Polarity Swap"]
            #[inline]
            pub fn polswap(&mut self) -> _POLSWAPW {
                _POLSWAPW { w: self }
            }
            #[doc = "Bits 15:19 - Fast Link Down Mode"]
            #[inline]
            pub fn fastldmode(&mut self) -> _FASTLDMODEW {
                _FASTLDMODEW { w: self }
            }
            #[doc = "Bit 20 - TDR Auto Run"]
            #[inline]
            pub fn tdrrun(&mut self) -> _TDRRUNW {
                _TDRRUNW { w: self }
            }
            #[doc = "Bit 21 - Link Loss Recovery"]
            #[inline]
            pub fn lrr(&mut self) -> _LRRW {
                _LRRW { w: self }
            }
            #[doc = "Bit 22 - Isolate MII in Link Loss"]
            #[inline]
            pub fn isomiill(&mut self) -> _ISOMIILLW {
                _ISOMIILLW { w: self }
            }
            #[doc = "Bit 23 - RXER Detection During Idle"]
            #[inline]
            pub fn rxeridle(&mut self) -> _RXERIDLEW {
                _RXERIDLEW { w: self }
            }
            #[doc = "Bit 24 - Odd Nibble TXER Detection Disable"]
            #[inline]
            pub fn nibdetdis(&mut self) -> _NIBDETDISW {
                _NIBDETDISW { w: self }
            }
            #[doc = "Bit 25 - PHY Soft Restart"]
            #[inline]
            pub fn digrestart(&mut self) -> _DIGRESTARTW {
                _DIGRESTARTW { w: self }
            }
            #[doc = "Bits 28:30 - Ethernet Interface Select"]
            #[inline]
            pub fn pintfs(&mut self) -> _PINTFSW {
                _PINTFSW { w: self }
            }
            #[doc = "Bit 31 - PHY Select"]
            #[inline]
            pub fn phyext(&mut self) -> _PHYEXTW {
                _PHYEXTW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Clock Configuration Register"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Clock Configuration Register"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct POLR {
            bits: bool,
        }
        impl POLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PTPCENR {
            bits: bool,
        }
        impl PTPCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 17 - LED Polarity Control"]
            #[inline]
            pub fn pol(&self) -> POLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                POLR { bits }
            }
            #[doc = "Bit 18 - PTP Clock Reference Enable"]
            #[inline]
            pub fn ptpcen(&self) -> PTPCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PTPCENR { bits }
            }
        }
    }
    #[doc = "Ethernet PHY Raw Interrupt Status"]
    pub struct EPHYRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Raw Interrupt Status"]
    pub mod ephyris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::EPHYRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTR {
            bits: bool,
        }
        impl INTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Raw Interrupt Status"]
            #[inline]
            pub fn int(&self) -> INTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTR { bits }
            }
        }
    }
    #[doc = "Ethernet PHY Interrupt Mask"]
    pub struct EPHYIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Interrupt Mask"]
    pub mod ephyim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EPHYIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTR {
            bits: bool,
        }
        impl INTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Interrupt Mask"]
            #[inline]
            pub fn int(&self) -> INTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTR { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Interrupt Mask"]
            #[inline]
            pub fn int(&mut self) -> _INTW {
                _INTW { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Masked Interrupt Status and Clear"]
    pub struct EPHYMISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Masked Interrupt Status and Clear"]
    pub mod ephymisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EPHYMISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct INTR {
            bits: bool,
        }
        impl INTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _INTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INTW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Status and Clear register"]
            #[inline]
            pub fn int(&self) -> INTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INTR { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Status and Clear register"]
            #[inline]
            pub fn int(&mut self) -> _INTW {
                _INTW { w: self }
            }
        }
    }
}
#[doc = "System Exception Module register addresses"]
pub struct SYSEXC {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSEXC {}
impl SYSEXC {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const sysexc::RegisterBlock {
        0x400f_9000 as *const _
    }
}
impl Deref for SYSEXC {
    type Target = sysexc::RegisterBlock;
    fn deref(&self) -> &sysexc::RegisterBlock {
        unsafe { &*SYSEXC::ptr() }
    }
}
#[doc = "System Exception Module register addresses"]
pub mod sysexc {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - System Exception Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x04 - System Exception Interrupt Mask"]
        pub im: IM,
        #[doc = "0x08 - System Exception Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x0c - System Exception Interrupt Clear"]
        pub ic: IC,
    }
    #[doc = "System Exception Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "System Exception Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIDCRISR {
            bits: bool,
        }
        impl FPIDCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPDZCRISR {
            bits: bool,
        }
        impl FPDZCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIOCRISR {
            bits: bool,
        }
        impl FPIOCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPUFCRISR {
            bits: bool,
        }
        impl FPUFCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPOFCRISR {
            bits: bool,
        }
        impl FPOFCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIXCRISR {
            bits: bool,
        }
        impl FPIXCRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Floating-Point Input Denormal Exception Raw Interrupt Status"]
            #[inline]
            pub fn fpidcris(&self) -> FPIDCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIDCRISR { bits }
            }
            #[doc = "Bit 1 - Floating-Point Divide By 0 Exception Raw Interrupt Status"]
            #[inline]
            pub fn fpdzcris(&self) -> FPDZCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPDZCRISR { bits }
            }
            #[doc = "Bit 2 - Floating-Point Invalid Operation Raw Interrupt Status"]
            #[inline]
            pub fn fpiocris(&self) -> FPIOCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIOCRISR { bits }
            }
            #[doc = "Bit 3 - Floating-Point Underflow Exception Raw Interrupt Status"]
            #[inline]
            pub fn fpufcris(&self) -> FPUFCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPUFCRISR { bits }
            }
            #[doc = "Bit 4 - Floating-Point Overflow Exception Raw Interrupt Status"]
            #[inline]
            pub fn fpofcris(&self) -> FPOFCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPOFCRISR { bits }
            }
            #[doc = "Bit 5 - Floating-Point Inexact Exception Raw Interrupt Status"]
            #[inline]
            pub fn fpixcris(&self) -> FPIXCRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIXCRISR { bits }
            }
        }
    }
    #[doc = "System Exception Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "System Exception Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIDCIMR {
            bits: bool,
        }
        impl FPIDCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPDZCIMR {
            bits: bool,
        }
        impl FPDZCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIOCIMR {
            bits: bool,
        }
        impl FPIOCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPUFCIMR {
            bits: bool,
        }
        impl FPUFCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPOFCIMR {
            bits: bool,
        }
        impl FPOFCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIXCIMR {
            bits: bool,
        }
        impl FPIXCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPIDCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIDCIMW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPDZCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPDZCIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPIOCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIOCIMW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPUFCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPUFCIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPOFCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPOFCIMW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPIXCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIXCIMW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Floating-Point Input Denormal Exception Interrupt Mask"]
            #[inline]
            pub fn fpidcim(&self) -> FPIDCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIDCIMR { bits }
            }
            #[doc = "Bit 1 - Floating-Point Divide By 0 Exception Interrupt Mask"]
            #[inline]
            pub fn fpdzcim(&self) -> FPDZCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPDZCIMR { bits }
            }
            #[doc = "Bit 2 - Floating-Point Invalid Operation Interrupt Mask"]
            #[inline]
            pub fn fpiocim(&self) -> FPIOCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIOCIMR { bits }
            }
            #[doc = "Bit 3 - Floating-Point Underflow Exception Interrupt Mask"]
            #[inline]
            pub fn fpufcim(&self) -> FPUFCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPUFCIMR { bits }
            }
            #[doc = "Bit 4 - Floating-Point Overflow Exception Interrupt Mask"]
            #[inline]
            pub fn fpofcim(&self) -> FPOFCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPOFCIMR { bits }
            }
            #[doc = "Bit 5 - Floating-Point Inexact Exception Interrupt Mask"]
            #[inline]
            pub fn fpixcim(&self) -> FPIXCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIXCIMR { bits }
            }
        }
        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 = "Bit 0 - Floating-Point Input Denormal Exception Interrupt Mask"]
            #[inline]
            pub fn fpidcim(&mut self) -> _FPIDCIMW {
                _FPIDCIMW { w: self }
            }
            #[doc = "Bit 1 - Floating-Point Divide By 0 Exception Interrupt Mask"]
            #[inline]
            pub fn fpdzcim(&mut self) -> _FPDZCIMW {
                _FPDZCIMW { w: self }
            }
            #[doc = "Bit 2 - Floating-Point Invalid Operation Interrupt Mask"]
            #[inline]
            pub fn fpiocim(&mut self) -> _FPIOCIMW {
                _FPIOCIMW { w: self }
            }
            #[doc = "Bit 3 - Floating-Point Underflow Exception Interrupt Mask"]
            #[inline]
            pub fn fpufcim(&mut self) -> _FPUFCIMW {
                _FPUFCIMW { w: self }
            }
            #[doc = "Bit 4 - Floating-Point Overflow Exception Interrupt Mask"]
            #[inline]
            pub fn fpofcim(&mut self) -> _FPOFCIMW {
                _FPOFCIMW { w: self }
            }
            #[doc = "Bit 5 - Floating-Point Inexact Exception Interrupt Mask"]
            #[inline]
            pub fn fpixcim(&mut self) -> _FPIXCIMW {
                _FPIXCIMW { w: self }
            }
        }
    }
    #[doc = "System Exception Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "System Exception Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIDCMISR {
            bits: bool,
        }
        impl FPIDCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPDZCMISR {
            bits: bool,
        }
        impl FPDZCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIOCMISR {
            bits: bool,
        }
        impl FPIOCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPUFCMISR {
            bits: bool,
        }
        impl FPUFCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPOFCMISR {
            bits: bool,
        }
        impl FPOFCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPIXCMISR {
            bits: bool,
        }
        impl FPIXCMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Floating-Point Input Denormal Exception Masked Interrupt Status"]
            #[inline]
            pub fn fpidcmis(&self) -> FPIDCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIDCMISR { bits }
            }
            #[doc = "Bit 1 - Floating-Point Divide By 0 Exception Masked Interrupt Status"]
            #[inline]
            pub fn fpdzcmis(&self) -> FPDZCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPDZCMISR { bits }
            }
            #[doc = "Bit 2 - Floating-Point Invalid Operation Masked Interrupt Status"]
            #[inline]
            pub fn fpiocmis(&self) -> FPIOCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIOCMISR { bits }
            }
            #[doc = "Bit 3 - Floating-Point Underflow Exception Masked Interrupt Status"]
            #[inline]
            pub fn fpufcmis(&self) -> FPUFCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPUFCMISR { bits }
            }
            #[doc = "Bit 4 - Floating-Point Overflow Exception Masked Interrupt Status"]
            #[inline]
            pub fn fpofcmis(&self) -> FPOFCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPOFCMISR { bits }
            }
            #[doc = "Bit 5 - Floating-Point Inexact Exception Masked Interrupt Status"]
            #[inline]
            pub fn fpixcmis(&self) -> FPIXCMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPIXCMISR { bits }
            }
        }
    }
    #[doc = "System Exception Interrupt Clear"]
    pub struct IC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "System Exception Interrupt Clear"]
    pub mod ic {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IC {
            #[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 _FPIDCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIDCICW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPDZCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPDZCICW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPIOCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIOCICW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPUFCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPUFCICW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPOFCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPOFCICW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPIXCICW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPIXCICW<'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 = 5;
                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 = "Bit 0 - Floating-Point Input Denormal Exception Interrupt Clear"]
            #[inline]
            pub fn fpidcic(&mut self) -> _FPIDCICW {
                _FPIDCICW { w: self }
            }
            #[doc = "Bit 1 - Floating-Point Divide By 0 Exception Interrupt Clear"]
            #[inline]
            pub fn fpdzcic(&mut self) -> _FPDZCICW {
                _FPDZCICW { w: self }
            }
            #[doc = "Bit 2 - Floating-Point Invalid Operation Interrupt Clear"]
            #[inline]
            pub fn fpiocic(&mut self) -> _FPIOCICW {
                _FPIOCICW { w: self }
            }
            #[doc = "Bit 3 - Floating-Point Underflow Exception Interrupt Clear"]
            #[inline]
            pub fn fpufcic(&mut self) -> _FPUFCICW {
                _FPUFCICW { w: self }
            }
            #[doc = "Bit 4 - Floating-Point Overflow Exception Interrupt Clear"]
            #[inline]
            pub fn fpofcic(&mut self) -> _FPOFCICW {
                _FPOFCICW { w: self }
            }
            #[doc = "Bit 5 - Floating-Point Inexact Exception Interrupt Clear"]
            #[inline]
            pub fn fpixcic(&mut self) -> _FPIXCICW {
                _FPIXCICW { w: self }
            }
        }
    }
}
#[doc = "Hibernation module register addresses"]
pub struct HIB {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for HIB {}
impl HIB {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const hib::RegisterBlock {
        0x400f_c000 as *const _
    }
}
impl Deref for HIB {
    type Target = hib::RegisterBlock;
    fn deref(&self) -> &hib::RegisterBlock {
        unsafe { &*HIB::ptr() }
    }
}
#[doc = "Hibernation module register addresses"]
pub mod hib {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Hibernation RTC Counter"]
        pub rtcc: RTCC,
        #[doc = "0x04 - Hibernation RTC Match 0"]
        pub rtcm0: RTCM0,
        _reserved0: [u8; 4usize],
        #[doc = "0x0c - Hibernation RTC Load"]
        pub rtcld: RTCLD,
        #[doc = "0x10 - Hibernation Control"]
        pub ctl: CTL,
        #[doc = "0x14 - Hibernation Interrupt Mask"]
        pub im: IM,
        #[doc = "0x18 - Hibernation Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x1c - Hibernation Masked Interrupt Status"]
        pub mis: MIS,
        #[doc = "0x20 - Hibernation Interrupt Clear"]
        pub ic: IC,
        #[doc = "0x24 - Hibernation RTC Trim"]
        pub rtct: RTCT,
        #[doc = "0x28 - Hibernation RTC Sub Seconds"]
        pub rtcss: RTCSS,
        #[doc = "0x2c - Hibernation IO Configuration"]
        pub io: IO,
        #[doc = "0x30 - Hibernation Data"]
        pub data: DATA,
        _reserved1: [u8; 716usize],
        #[doc = "0x300 - Hibernation Calendar Control"]
        pub calctl: CALCTL,
        _reserved2: [u8; 12usize],
        #[doc = "0x310 - Hibernation Calendar 0"]
        pub cal0: CAL0,
        #[doc = "0x314 - Hibernation Calendar 1"]
        pub cal1: CAL1,
        _reserved3: [u8; 8usize],
        #[doc = "0x320 - Hibernation Calendar Load 0"]
        pub calld0: CALLD0,
        #[doc = "0x324 - Hibernation Calendar Load"]
        pub calld1: CALLD1,
        _reserved4: [u8; 8usize],
        #[doc = "0x330 - Hibernation Calendar Match 0"]
        pub calm0: CALM0,
        #[doc = "0x334 - Hibernation Calendar Match 1"]
        pub calm1: CALM1,
        _reserved5: [u8; 40usize],
        #[doc = "0x360 - Hibernation Lock"]
        pub lock: LOCK,
        _reserved6: [u8; 156usize],
        #[doc = "0x400 - HIB Tamper Control"]
        pub tpctl: TPCTL,
        #[doc = "0x404 - HIB Tamper Status"]
        pub tpstat: TPSTAT,
        _reserved7: [u8; 8usize],
        #[doc = "0x410 - HIB Tamper I/O Control"]
        pub tpio: TPIO,
        _reserved8: [u8; 204usize],
        #[doc = "0x4e0 - HIB Tamper Log 0"]
        pub tplog0: TPLOG0,
        #[doc = "0x4e4 - HIB Tamper Log 1"]
        pub tplog1: TPLOG1,
        #[doc = "0x4e8 - HIB Tamper Log 2"]
        pub tplog2: TPLOG2,
        #[doc = "0x4ec - HIB Tamper Log 3"]
        pub tplog3: TPLOG3,
        #[doc = "0x4f0 - HIB Tamper Log 4"]
        pub tplog4: TPLOG4,
        #[doc = "0x4f4 - HIB Tamper Log 5"]
        pub tplog5: TPLOG5,
        #[doc = "0x4f8 - HIB Tamper Log 6"]
        pub tplog6: TPLOG6,
        #[doc = "0x4fc - HIB Tamper Log 7"]
        pub tplog7: TPLOG7,
        _reserved9: [u8; 2752usize],
        #[doc = "0xfc0 - Hibernation Peripheral Properties"]
        pub pp: PP,
        _reserved10: [u8; 4usize],
        #[doc = "0xfc8 - Hibernation Clock Control"]
        pub cc: CC,
    }
    #[doc = "Hibernation RTC Counter"]
    pub struct RTCC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation RTC Counter"]
    pub mod rtcc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RTCC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
    }
    #[doc = "Hibernation RTC Match 0"]
    pub struct RTCM0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation RTC Match 0"]
    pub mod rtcm0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RTCM0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Hibernation RTC Load"]
    pub struct RTCLD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation RTC Load"]
    pub mod rtcld {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RTCLD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Hibernation Control"]
    pub struct CTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Control"]
    pub mod ctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCENR {
            bits: bool,
        }
        impl RTCENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HIBREQR {
            bits: bool,
        }
        impl HIBREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCWENR {
            bits: bool,
        }
        impl RTCWENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PINWENR {
            bits: bool,
        }
        impl PINWENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLK32ENR {
            bits: bool,
        }
        impl CLK32ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VABORTR {
            bits: bool,
        }
        impl VABORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDD3ONR {
            bits: bool,
        }
        impl VDD3ONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BATWKENR {
            bits: bool,
        }
        impl BATWKENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BATCHKR {
            bits: bool,
        }
        impl BATCHKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `VBATSEL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VBATSELR {
            #[doc = "1.9 Volts"]
            _1_9V,
            #[doc = "2.1 Volts (default)"]
            _2_1V,
            #[doc = "2.3 Volts"]
            _2_3V,
            #[doc = "2.5 Volts"]
            _2_5V,
        }
        impl VBATSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VBATSELR::_1_9V => 0,
                    VBATSELR::_2_1V => 0x01,
                    VBATSELR::_2_3V => 0x02,
                    VBATSELR::_2_5V => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VBATSELR {
                match value {
                    0 => VBATSELR::_1_9V,
                    1 => VBATSELR::_2_1V,
                    2 => VBATSELR::_2_3V,
                    3 => VBATSELR::_2_5V,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_1_9V`"]
            #[inline]
            pub fn is_1_9v(&self) -> bool {
                *self == VBATSELR::_1_9V
            }
            #[doc = "Checks if the value of the field is `_2_1V`"]
            #[inline]
            pub fn is_2_1v(&self) -> bool {
                *self == VBATSELR::_2_1V
            }
            #[doc = "Checks if the value of the field is `_2_3V`"]
            #[inline]
            pub fn is_2_3v(&self) -> bool {
                *self == VBATSELR::_2_3V
            }
            #[doc = "Checks if the value of the field is `_2_5V`"]
            #[inline]
            pub fn is_2_5v(&self) -> bool {
                *self == VBATSELR::_2_5V
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSCBYPR {
            bits: bool,
        }
        impl OSCBYPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSCDRVR {
            bits: bool,
        }
        impl OSCDRVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSCSELR {
            bits: bool,
        }
        impl OSCSELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RETCLRR {
            bits: bool,
        }
        impl RETCLRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRCR {
            bits: bool,
        }
        impl WRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _HIBREQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HIBREQW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCWENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCWENW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PINWENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PINWENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLK32ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLK32ENW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VABORTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VABORTW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDD3ONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDD3ONW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BATWKENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BATWKENW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BATCHKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BATCHKW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `VBATSEL`"]
        pub enum VBATSELW {
            #[doc = "1.9 Volts"]
            _1_9V,
            #[doc = "2.1 Volts (default)"]
            _2_1V,
            #[doc = "2.3 Volts"]
            _2_3V,
            #[doc = "2.5 Volts"]
            _2_5V,
        }
        impl VBATSELW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VBATSELW::_1_9V => 0,
                    VBATSELW::_2_1V => 1,
                    VBATSELW::_2_3V => 2,
                    VBATSELW::_2_5V => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VBATSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VBATSELW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VBATSELW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "1.9 Volts"]
            #[inline]
            pub fn _1_9v(self) -> &'a mut W {
                self.variant(VBATSELW::_1_9V)
            }
            #[doc = "2.1 Volts (default)"]
            #[inline]
            pub fn _2_1v(self) -> &'a mut W {
                self.variant(VBATSELW::_2_1V)
            }
            #[doc = "2.3 Volts"]
            #[inline]
            pub fn _2_3v(self) -> &'a mut W {
                self.variant(VBATSELW::_2_3V)
            }
            #[doc = "2.5 Volts"]
            #[inline]
            pub fn _2_5v(self) -> &'a mut W {
                self.variant(VBATSELW::_2_5V)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSCBYPW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSCBYPW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSCDRVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSCDRVW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSCSELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSCSELW<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RETCLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RETCLRW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRCW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Timer Enable"]
            #[inline]
            pub fn rtcen(&self) -> RTCENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCENR { bits }
            }
            #[doc = "Bit 1 - Hibernation Request"]
            #[inline]
            pub fn hibreq(&self) -> HIBREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HIBREQR { bits }
            }
            #[doc = "Bit 3 - RTC Wake-up Enable"]
            #[inline]
            pub fn rtcwen(&self) -> RTCWENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCWENR { bits }
            }
            #[doc = "Bit 4 - External Wake Pin Enable"]
            #[inline]
            pub fn pinwen(&self) -> PINWENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PINWENR { bits }
            }
            #[doc = "Bit 6 - Clocking Enable"]
            #[inline]
            pub fn clk32en(&self) -> CLK32ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLK32ENR { bits }
            }
            #[doc = "Bit 7 - Power Cut Abort Enable"]
            #[inline]
            pub fn vabort(&self) -> VABORTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VABORTR { bits }
            }
            #[doc = "Bit 8 - VDD Powered"]
            #[inline]
            pub fn vdd3on(&self) -> VDD3ONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDD3ONR { bits }
            }
            #[doc = "Bit 9 - Wake on Low Battery"]
            #[inline]
            pub fn batwken(&self) -> BATWKENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BATWKENR { bits }
            }
            #[doc = "Bit 10 - Check Battery Status"]
            #[inline]
            pub fn batchk(&self) -> BATCHKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BATCHKR { bits }
            }
            #[doc = "Bits 13:14 - Select for Low-Battery Comparator"]
            #[inline]
            pub fn vbatsel(&self) -> VBATSELR {
                VBATSELR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 16 - Oscillator Bypass"]
            #[inline]
            pub fn oscbyp(&self) -> OSCBYPR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OSCBYPR { bits }
            }
            #[doc = "Bit 17 - Oscillator Drive Capability"]
            #[inline]
            pub fn oscdrv(&self) -> OSCDRVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OSCDRVR { bits }
            }
            #[doc = "Bit 19 - Oscillator Select"]
            #[inline]
            pub fn oscsel(&self) -> OSCSELR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OSCSELR { bits }
            }
            #[doc = "Bit 30 - GPIO Retention/Clear"]
            #[inline]
            pub fn retclr(&self) -> RETCLRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RETCLRR { bits }
            }
            #[doc = "Bit 31 - Write Complete/Capable"]
            #[inline]
            pub fn wrc(&self) -> WRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRCR { bits }
            }
        }
        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 = "Bit 0 - RTC Timer Enable"]
            #[inline]
            pub fn rtcen(&mut self) -> _RTCENW {
                _RTCENW { w: self }
            }
            #[doc = "Bit 1 - Hibernation Request"]
            #[inline]
            pub fn hibreq(&mut self) -> _HIBREQW {
                _HIBREQW { w: self }
            }
            #[doc = "Bit 3 - RTC Wake-up Enable"]
            #[inline]
            pub fn rtcwen(&mut self) -> _RTCWENW {
                _RTCWENW { w: self }
            }
            #[doc = "Bit 4 - External Wake Pin Enable"]
            #[inline]
            pub fn pinwen(&mut self) -> _PINWENW {
                _PINWENW { w: self }
            }
            #[doc = "Bit 6 - Clocking Enable"]
            #[inline]
            pub fn clk32en(&mut self) -> _CLK32ENW {
                _CLK32ENW { w: self }
            }
            #[doc = "Bit 7 - Power Cut Abort Enable"]
            #[inline]
            pub fn vabort(&mut self) -> _VABORTW {
                _VABORTW { w: self }
            }
            #[doc = "Bit 8 - VDD Powered"]
            #[inline]
            pub fn vdd3on(&mut self) -> _VDD3ONW {
                _VDD3ONW { w: self }
            }
            #[doc = "Bit 9 - Wake on Low Battery"]
            #[inline]
            pub fn batwken(&mut self) -> _BATWKENW {
                _BATWKENW { w: self }
            }
            #[doc = "Bit 10 - Check Battery Status"]
            #[inline]
            pub fn batchk(&mut self) -> _BATCHKW {
                _BATCHKW { w: self }
            }
            #[doc = "Bits 13:14 - Select for Low-Battery Comparator"]
            #[inline]
            pub fn vbatsel(&mut self) -> _VBATSELW {
                _VBATSELW { w: self }
            }
            #[doc = "Bit 16 - Oscillator Bypass"]
            #[inline]
            pub fn oscbyp(&mut self) -> _OSCBYPW {
                _OSCBYPW { w: self }
            }
            #[doc = "Bit 17 - Oscillator Drive Capability"]
            #[inline]
            pub fn oscdrv(&mut self) -> _OSCDRVW {
                _OSCDRVW { w: self }
            }
            #[doc = "Bit 19 - Oscillator Select"]
            #[inline]
            pub fn oscsel(&mut self) -> _OSCSELW {
                _OSCSELW { w: self }
            }
            #[doc = "Bit 30 - GPIO Retention/Clear"]
            #[inline]
            pub fn retclr(&mut self) -> _RETCLRW {
                _RETCLRW { w: self }
            }
            #[doc = "Bit 31 - Write Complete/Capable"]
            #[inline]
            pub fn wrc(&mut self) -> _WRCW {
                _WRCW { w: self }
            }
        }
    }
    #[doc = "Hibernation Interrupt Mask"]
    pub struct IM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Interrupt Mask"]
    pub mod im {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCALT0R {
            bits: bool,
        }
        impl RTCALT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOWBATR {
            bits: bool,
        }
        impl LOWBATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTWR {
            bits: bool,
        }
        impl EXTWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WCR {
            bits: bool,
        }
        impl WCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PADIOWKR {
            bits: bool,
        }
        impl PADIOWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTWKR {
            bits: bool,
        }
        impl RSTWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDDFAILR {
            bits: bool,
        }
        impl VDDFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCALT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCALT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOWBATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOWBATW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTWW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WCW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PADIOWKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PADIOWKW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSTWKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSTWKW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDDFAILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDDFAILW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Alert 0 Interrupt Mask"]
            #[inline]
            pub fn rtcalt0(&self) -> RTCALT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCALT0R { bits }
            }
            #[doc = "Bit 2 - Low Battery Voltage Interrupt Mask"]
            #[inline]
            pub fn lowbat(&self) -> LOWBATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOWBATR { bits }
            }
            #[doc = "Bit 3 - External Wake-Up Interrupt Mask"]
            #[inline]
            pub fn extw(&self) -> EXTWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTWR { bits }
            }
            #[doc = "Bit 4 - External Write Complete/Capable Interrupt Mask"]
            #[inline]
            pub fn wc(&self) -> WCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WCR { bits }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn padiowk(&self) -> PADIOWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PADIOWKR { bits }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn rstwk(&self) -> RSTWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTWKR { bits }
            }
            #[doc = "Bit 7 - VDD Fail Interrupt Mask"]
            #[inline]
            pub fn vddfail(&self) -> VDDFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDDFAILR { bits }
            }
        }
        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 = "Bit 0 - RTC Alert 0 Interrupt Mask"]
            #[inline]
            pub fn rtcalt0(&mut self) -> _RTCALT0W {
                _RTCALT0W { w: self }
            }
            #[doc = "Bit 2 - Low Battery Voltage Interrupt Mask"]
            #[inline]
            pub fn lowbat(&mut self) -> _LOWBATW {
                _LOWBATW { w: self }
            }
            #[doc = "Bit 3 - External Wake-Up Interrupt Mask"]
            #[inline]
            pub fn extw(&mut self) -> _EXTWW {
                _EXTWW { w: self }
            }
            #[doc = "Bit 4 - External Write Complete/Capable Interrupt Mask"]
            #[inline]
            pub fn wc(&mut self) -> _WCW {
                _WCW { w: self }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn padiowk(&mut self) -> _PADIOWKW {
                _PADIOWKW { w: self }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn rstwk(&mut self) -> _RSTWKW {
                _RSTWKW { w: self }
            }
            #[doc = "Bit 7 - VDD Fail Interrupt Mask"]
            #[inline]
            pub fn vddfail(&mut self) -> _VDDFAILW {
                _VDDFAILW { w: self }
            }
        }
    }
    #[doc = "Hibernation Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCALT0R {
            bits: bool,
        }
        impl RTCALT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOWBATR {
            bits: bool,
        }
        impl LOWBATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTWR {
            bits: bool,
        }
        impl EXTWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WCR {
            bits: bool,
        }
        impl WCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PADIOWKR {
            bits: bool,
        }
        impl PADIOWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTWKR {
            bits: bool,
        }
        impl RSTWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDDFAILR {
            bits: bool,
        }
        impl VDDFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Alert 0 Raw Interrupt Status"]
            #[inline]
            pub fn rtcalt0(&self) -> RTCALT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCALT0R { bits }
            }
            #[doc = "Bit 2 - Low Battery Voltage Raw Interrupt Status"]
            #[inline]
            pub fn lowbat(&self) -> LOWBATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOWBATR { bits }
            }
            #[doc = "Bit 3 - External Wake-Up Raw Interrupt Status"]
            #[inline]
            pub fn extw(&self) -> EXTWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTWR { bits }
            }
            #[doc = "Bit 4 - Write Complete/Capable Raw Interrupt Status"]
            #[inline]
            pub fn wc(&self) -> WCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WCR { bits }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Raw Interrupt Status"]
            #[inline]
            pub fn padiowk(&self) -> PADIOWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PADIOWKR { bits }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Raw Interrupt Status"]
            #[inline]
            pub fn rstwk(&self) -> RSTWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTWKR { bits }
            }
            #[doc = "Bit 7 - VDD Fail Raw Interrupt Status"]
            #[inline]
            pub fn vddfail(&self) -> VDDFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDDFAILR { bits }
            }
        }
    }
    #[doc = "Hibernation Masked Interrupt Status"]
    pub struct MIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Masked Interrupt Status"]
    pub mod mis {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::MIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCALT0R {
            bits: bool,
        }
        impl RTCALT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOWBATR {
            bits: bool,
        }
        impl LOWBATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTWR {
            bits: bool,
        }
        impl EXTWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WCR {
            bits: bool,
        }
        impl WCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PADIOWKR {
            bits: bool,
        }
        impl PADIOWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTWKR {
            bits: bool,
        }
        impl RSTWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDDFAILR {
            bits: bool,
        }
        impl VDDFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Alert 0 Masked Interrupt Status"]
            #[inline]
            pub fn rtcalt0(&self) -> RTCALT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCALT0R { bits }
            }
            #[doc = "Bit 2 - Low Battery Voltage Masked Interrupt Status"]
            #[inline]
            pub fn lowbat(&self) -> LOWBATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOWBATR { bits }
            }
            #[doc = "Bit 3 - External Wake-Up Masked Interrupt Status"]
            #[inline]
            pub fn extw(&self) -> EXTWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTWR { bits }
            }
            #[doc = "Bit 4 - Write Complete/Capable Masked Interrupt Status"]
            #[inline]
            pub fn wc(&self) -> WCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WCR { bits }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn padiowk(&self) -> PADIOWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PADIOWKR { bits }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Interrupt Mask"]
            #[inline]
            pub fn rstwk(&self) -> RSTWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTWKR { bits }
            }
            #[doc = "Bit 7 - VDD Fail Interrupt Mask"]
            #[inline]
            pub fn vddfail(&self) -> VDDFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDDFAILR { bits }
            }
        }
    }
    #[doc = "Hibernation Interrupt Clear"]
    pub struct IC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Interrupt Clear"]
    pub mod ic {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCALT0R {
            bits: bool,
        }
        impl RTCALT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOWBATR {
            bits: bool,
        }
        impl LOWBATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTWR {
            bits: bool,
        }
        impl EXTWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WCR {
            bits: bool,
        }
        impl WCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PADIOWKR {
            bits: bool,
        }
        impl PADIOWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSTWKR {
            bits: bool,
        }
        impl RSTWKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDDFAILR {
            bits: bool,
        }
        impl VDDFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCALT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCALT0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _LOWBATW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LOWBATW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTWW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WCW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PADIOWKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PADIOWKW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RSTWKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RSTWKW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDDFAILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDDFAILW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Alert0 Masked Interrupt Clear"]
            #[inline]
            pub fn rtcalt0(&self) -> RTCALT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RTCALT0R { bits }
            }
            #[doc = "Bit 2 - Low Battery Voltage Interrupt Clear"]
            #[inline]
            pub fn lowbat(&self) -> LOWBATR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOWBATR { bits }
            }
            #[doc = "Bit 3 - External Wake-Up Interrupt Clear"]
            #[inline]
            pub fn extw(&self) -> EXTWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTWR { bits }
            }
            #[doc = "Bit 4 - Write Complete/Capable Interrupt Clear"]
            #[inline]
            pub fn wc(&self) -> WCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WCR { bits }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Interrupt Clear"]
            #[inline]
            pub fn padiowk(&self) -> PADIOWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PADIOWKR { bits }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Interrupt Clear"]
            #[inline]
            pub fn rstwk(&self) -> RSTWKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RSTWKR { bits }
            }
            #[doc = "Bit 7 - VDD Fail Interrupt Clear"]
            #[inline]
            pub fn vddfail(&self) -> VDDFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDDFAILR { bits }
            }
        }
        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 = "Bit 0 - RTC Alert0 Masked Interrupt Clear"]
            #[inline]
            pub fn rtcalt0(&mut self) -> _RTCALT0W {
                _RTCALT0W { w: self }
            }
            #[doc = "Bit 2 - Low Battery Voltage Interrupt Clear"]
            #[inline]
            pub fn lowbat(&mut self) -> _LOWBATW {
                _LOWBATW { w: self }
            }
            #[doc = "Bit 3 - External Wake-Up Interrupt Clear"]
            #[inline]
            pub fn extw(&mut self) -> _EXTWW {
                _EXTWW { w: self }
            }
            #[doc = "Bit 4 - Write Complete/Capable Interrupt Clear"]
            #[inline]
            pub fn wc(&mut self) -> _WCW {
                _WCW { w: self }
            }
            #[doc = "Bit 5 - Pad I/O Wake-Up Interrupt Clear"]
            #[inline]
            pub fn padiowk(&mut self) -> _PADIOWKW {
                _PADIOWKW { w: self }
            }
            #[doc = "Bit 6 - Reset Pad I/O Wake-Up Interrupt Clear"]
            #[inline]
            pub fn rstwk(&mut self) -> _RSTWKW {
                _RSTWKW { w: self }
            }
            #[doc = "Bit 7 - VDD Fail Interrupt Clear"]
            #[inline]
            pub fn vddfail(&mut self) -> _VDDFAILW {
                _VDDFAILW { w: self }
            }
        }
    }
    #[doc = "Hibernation RTC Trim"]
    pub struct RTCT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation RTC Trim"]
    pub mod rtct {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RTCT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIMR {
            bits: u16,
        }
        impl TRIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _TRIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TRIMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - RTC Trim Value"]
            #[inline]
            pub fn trim(&self) -> TRIMR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                TRIMR { bits }
            }
        }
        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 0:15 - RTC Trim Value"]
            #[inline]
            pub fn trim(&mut self) -> _TRIMW {
                _TRIMW { w: self }
            }
        }
    }
    #[doc = "Hibernation RTC Sub Seconds"]
    pub struct RTCSS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation RTC Sub Seconds"]
    pub mod rtcss {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RTCSS {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCSSCR {
            bits: u16,
        }
        impl RTCSSCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTCSSMR {
            bits: u16,
        }
        impl RTCSSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCSSCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCSSCW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x7fff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTCSSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTCSSMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x7fff;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:14 - RTC Sub Seconds Count"]
            #[inline]
            pub fn rtcssc(&self) -> RTCSSCR {
                let bits = {
                    const MASK: u16 = 0x7fff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RTCSSCR { bits }
            }
            #[doc = "Bits 16:30 - RTC Sub Seconds Match"]
            #[inline]
            pub fn rtcssm(&self) -> RTCSSMR {
                let bits = {
                    const MASK: u16 = 0x7fff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                RTCSSMR { bits }
            }
        }
        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 0:14 - RTC Sub Seconds Count"]
            #[inline]
            pub fn rtcssc(&mut self) -> _RTCSSCW {
                _RTCSSCW { w: self }
            }
            #[doc = "Bits 16:30 - RTC Sub Seconds Match"]
            #[inline]
            pub fn rtcssm(&mut self) -> _RTCSSMW {
                _RTCSSMW { w: self }
            }
        }
    }
    #[doc = "Hibernation IO Configuration"]
    pub struct IO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation IO Configuration"]
    pub mod io {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WUUNLKR {
            bits: bool,
        }
        impl WUUNLKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WURSTENR {
            bits: bool,
        }
        impl WURSTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct IOWRCR {
            bits: bool,
        }
        impl IOWRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _WUUNLKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WUUNLKW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _WURSTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WURSTENW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _IOWRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _IOWRCW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I/O Wake Pad Configuration Enable"]
            #[inline]
            pub fn wuunlk(&self) -> WUUNLKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WUUNLKR { bits }
            }
            #[doc = "Bit 4 - Reset Wake Source Enable"]
            #[inline]
            pub fn wursten(&self) -> WURSTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WURSTENR { bits }
            }
            #[doc = "Bit 31 - I/O Write Complete"]
            #[inline]
            pub fn iowrc(&self) -> IOWRCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                IOWRCR { bits }
            }
        }
        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 = "Bit 0 - I/O Wake Pad Configuration Enable"]
            #[inline]
            pub fn wuunlk(&mut self) -> _WUUNLKW {
                _WUUNLKW { w: self }
            }
            #[doc = "Bit 4 - Reset Wake Source Enable"]
            #[inline]
            pub fn wursten(&mut self) -> _WURSTENW {
                _WURSTENW { w: self }
            }
            #[doc = "Bit 31 - I/O Write Complete"]
            #[inline]
            pub fn iowrc(&mut self) -> _IOWRCW {
                _IOWRCW { w: self }
            }
        }
    }
    #[doc = "Hibernation Data"]
    pub struct DATA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Data"]
    pub mod data {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DATA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RTDR {
            bits: u32,
        }
        impl RTDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RTDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RTDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Hibernation Module NV Data"]
            #[inline]
            pub fn rtd(&self) -> RTDR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RTDR { bits }
            }
        }
        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 0:31 - Hibernation Module NV Data"]
            #[inline]
            pub fn rtd(&mut self) -> _RTDW {
                _RTDW { w: self }
            }
        }
    }
    #[doc = "Hibernation Calendar Control"]
    pub struct CALCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar Control"]
    pub mod calctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CALCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CALENR {
            bits: bool,
        }
        impl CALENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CAL24R {
            bits: bool,
        }
        impl CAL24R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CALENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CALENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _CAL24W<'a> {
            w: &'a mut W,
        }
        impl<'a> _CAL24W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTC Calendar/Counter Mode Select"]
            #[inline]
            pub fn calen(&self) -> CALENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CALENR { bits }
            }
            #[doc = "Bit 2 - Calendar Mode"]
            #[inline]
            pub fn cal24(&self) -> CAL24R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CAL24R { bits }
            }
        }
        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 = "Bit 0 - RTC Calendar/Counter Mode Select"]
            #[inline]
            pub fn calen(&mut self) -> _CALENW {
                _CALENW { w: self }
            }
            #[doc = "Bit 2 - Calendar Mode"]
            #[inline]
            pub fn cal24(&mut self) -> _CAL24W {
                _CAL24W { w: self }
            }
        }
    }
    #[doc = "Hibernation Calendar 0"]
    pub struct CAL0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar 0"]
    pub mod cal0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::CAL0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct SECR {
            bits: u8,
        }
        impl SECR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINR {
            bits: u8,
        }
        impl MINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HRR {
            bits: u8,
        }
        impl HRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct AMPMR {
            bits: bool,
        }
        impl AMPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VALIDR {
            bits: bool,
        }
        impl VALIDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Seconds"]
            #[inline]
            pub fn sec(&self) -> SECR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SECR { bits }
            }
            #[doc = "Bits 8:13 - Minutes"]
            #[inline]
            pub fn min(&self) -> MINR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MINR { bits }
            }
            #[doc = "Bits 16:20 - Hours"]
            #[inline]
            pub fn hr(&self) -> HRR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HRR { bits }
            }
            #[doc = "Bit 22 - AM/PM Designation"]
            #[inline]
            pub fn ampm(&self) -> AMPMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AMPMR { bits }
            }
            #[doc = "Bit 31 - Valid Calendar Load"]
            #[inline]
            pub fn valid(&self) -> VALIDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VALIDR { bits }
            }
        }
    }
    #[doc = "Hibernation Calendar 1"]
    pub struct CAL1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar 1"]
    pub mod cal1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::CAL1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DOMR {
            bits: u8,
        }
        impl DOMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MONR {
            bits: u8,
        }
        impl MONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct YEARR {
            bits: u8,
        }
        impl YEARR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct DOWR {
            bits: u8,
        }
        impl DOWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct VALIDR {
            bits: bool,
        }
        impl VALIDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:4 - Day of Month"]
            #[inline]
            pub fn dom(&self) -> DOMR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DOMR { bits }
            }
            #[doc = "Bits 8:11 - Month"]
            #[inline]
            pub fn mon(&self) -> MONR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MONR { bits }
            }
            #[doc = "Bits 16:22 - Year Value"]
            #[inline]
            pub fn year(&self) -> YEARR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                YEARR { bits }
            }
            #[doc = "Bits 24:26 - Day of Week"]
            #[inline]
            pub fn dow(&self) -> DOWR {
                let bits = {
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DOWR { bits }
            }
            #[doc = "Bit 31 - Valid Calendar Load"]
            #[inline]
            pub fn valid(&self) -> VALIDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VALIDR { bits }
            }
        }
    }
    #[doc = "Hibernation Calendar Load 0"]
    pub struct CALLD0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar Load 0"]
    pub mod calld0 {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CALLD0 {
            #[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 _SECW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SECW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                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 _HRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AMPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AMPMW<'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 = 22;
                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 0:5 - Seconds"]
            #[inline]
            pub fn sec(&mut self) -> _SECW {
                _SECW { w: self }
            }
            #[doc = "Bits 8:13 - Minutes"]
            #[inline]
            pub fn min(&mut self) -> _MINW {
                _MINW { w: self }
            }
            #[doc = "Bits 16:20 - Hours"]
            #[inline]
            pub fn hr(&mut self) -> _HRW {
                _HRW { w: self }
            }
            #[doc = "Bit 22 - AM/PM Designation"]
            #[inline]
            pub fn ampm(&mut self) -> _AMPMW {
                _AMPMW { w: self }
            }
        }
    }
    #[doc = "Hibernation Calendar Load"]
    pub struct CALLD1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar Load"]
    pub mod calld1 {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CALLD1 {
            #[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 _DOMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DOMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MONW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _YEARW<'a> {
            w: &'a mut W,
        }
        impl<'a> _YEARW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _DOWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DOWW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x07;
                const OFFSET: u8 = 24;
                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 0:4 - Day of Month"]
            #[inline]
            pub fn dom(&mut self) -> _DOMW {
                _DOMW { w: self }
            }
            #[doc = "Bits 8:11 - Month"]
            #[inline]
            pub fn mon(&mut self) -> _MONW {
                _MONW { w: self }
            }
            #[doc = "Bits 16:22 - Year Value"]
            #[inline]
            pub fn year(&mut self) -> _YEARW {
                _YEARW { w: self }
            }
            #[doc = "Bits 24:26 - Day of Week"]
            #[inline]
            pub fn dow(&mut self) -> _DOWW {
                _DOWW { w: self }
            }
        }
    }
    #[doc = "Hibernation Calendar Match 0"]
    pub struct CALM0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar Match 0"]
    pub mod calm0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CALM0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SECR {
            bits: u8,
        }
        impl SECR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINR {
            bits: u8,
        }
        impl MINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct HRR {
            bits: u8,
        }
        impl HRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct AMPMR {
            bits: bool,
        }
        impl AMPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SECW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SECW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x3f;
                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 _HRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _AMPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AMPMW<'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 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:5 - Seconds"]
            #[inline]
            pub fn sec(&self) -> SECR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                SECR { bits }
            }
            #[doc = "Bits 8:13 - Minutes"]
            #[inline]
            pub fn min(&self) -> MINR {
                let bits = {
                    const MASK: u8 = 0x3f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                MINR { bits }
            }
            #[doc = "Bits 16:20 - Hours"]
            #[inline]
            pub fn hr(&self) -> HRR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                HRR { bits }
            }
            #[doc = "Bit 22 - AM/PM Designation"]
            #[inline]
            pub fn ampm(&self) -> AMPMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AMPMR { bits }
            }
        }
        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 0:5 - Seconds"]
            #[inline]
            pub fn sec(&mut self) -> _SECW {
                _SECW { w: self }
            }
            #[doc = "Bits 8:13 - Minutes"]
            #[inline]
            pub fn min(&mut self) -> _MINW {
                _MINW { w: self }
            }
            #[doc = "Bits 16:20 - Hours"]
            #[inline]
            pub fn hr(&mut self) -> _HRW {
                _HRW { w: self }
            }
            #[doc = "Bit 22 - AM/PM Designation"]
            #[inline]
            pub fn ampm(&mut self) -> _AMPMW {
                _AMPMW { w: self }
            }
        }
    }
    #[doc = "Hibernation Calendar Match 1"]
    pub struct CALM1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Calendar Match 1"]
    pub mod calm1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CALM1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DOMR {
            bits: u8,
        }
        impl DOMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DOMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DOMW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:4 - Day of Month"]
            #[inline]
            pub fn dom(&self) -> DOMR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DOMR { bits }
            }
        }
        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 0:4 - Day of Month"]
            #[inline]
            pub fn dom(&mut self) -> _DOMW {
                _DOMW { w: self }
            }
        }
    }
    #[doc = "Hibernation Lock"]
    pub struct LOCK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Lock"]
    pub mod lock {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LOCK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct HIBLOCKR {
            bits: u32,
        }
        impl HIBLOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _HIBLOCKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HIBLOCKW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - HIbernate Lock"]
            #[inline]
            pub fn hiblock(&self) -> HIBLOCKR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                HIBLOCKR { bits }
            }
        }
        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 0:31 - HIbernate Lock"]
            #[inline]
            pub fn hiblock(&mut self) -> _HIBLOCKW {
                _HIBLOCKW { w: self }
            }
        }
    }
    #[doc = "HIB Tamper Control"]
    pub struct TPCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Control"]
    pub mod tpctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TPCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPENR {
            bits: bool,
        }
        impl TPENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TPCLRR {
            bits: bool,
        }
        impl TPCLRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `MEMCLR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MEMCLRR {
            #[doc = "Do not Clear HIB memory on tamper event"]
            NONE,
            #[doc = "Clear Lower 32 Bytes of HIB memory on tamper event"]
            LOW32,
            #[doc = "Clear upper 32 Bytes of HIB memory on tamper event"]
            HIGH32,
            #[doc = "Clear all HIB memory on tamper event"]
            ALL,
        }
        impl MEMCLRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MEMCLRR::NONE => 0,
                    MEMCLRR::LOW32 => 0x01,
                    MEMCLRR::HIGH32 => 0x02,
                    MEMCLRR::ALL => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MEMCLRR {
                match value {
                    0 => MEMCLRR::NONE,
                    1 => MEMCLRR::LOW32,
                    2 => MEMCLRR::HIGH32,
                    3 => MEMCLRR::ALL,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == MEMCLRR::NONE
            }
            #[doc = "Checks if the value of the field is `LOW32`"]
            #[inline]
            pub fn is_low32(&self) -> bool {
                *self == MEMCLRR::LOW32
            }
            #[doc = "Checks if the value of the field is `HIGH32`"]
            #[inline]
            pub fn is_high32(&self) -> bool {
                *self == MEMCLRR::HIGH32
            }
            #[doc = "Checks if the value of the field is `ALL`"]
            #[inline]
            pub fn is_all(&self) -> bool {
                *self == MEMCLRR::ALL
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAKER {
            bits: bool,
        }
        impl WAKER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _TPENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TPENW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _TPCLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TPCLRW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `MEMCLR`"]
        pub enum MEMCLRW {
            #[doc = "Do not Clear HIB memory on tamper event"]
            NONE,
            #[doc = "Clear Lower 32 Bytes of HIB memory on tamper event"]
            LOW32,
            #[doc = "Clear upper 32 Bytes of HIB memory on tamper event"]
            HIGH32,
            #[doc = "Clear all HIB memory on tamper event"]
            ALL,
        }
        impl MEMCLRW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    MEMCLRW::NONE => 0,
                    MEMCLRW::LOW32 => 1,
                    MEMCLRW::HIGH32 => 2,
                    MEMCLRW::ALL => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _MEMCLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MEMCLRW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: MEMCLRW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Do not Clear HIB memory on tamper event"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(MEMCLRW::NONE)
            }
            #[doc = "Clear Lower 32 Bytes of HIB memory on tamper event"]
            #[inline]
            pub fn low32(self) -> &'a mut W {
                self.variant(MEMCLRW::LOW32)
            }
            #[doc = "Clear upper 32 Bytes of HIB memory on tamper event"]
            #[inline]
            pub fn high32(self) -> &'a mut W {
                self.variant(MEMCLRW::HIGH32)
            }
            #[doc = "Clear all HIB memory on tamper event"]
            #[inline]
            pub fn all(self) -> &'a mut W {
                self.variant(MEMCLRW::ALL)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                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 _WAKEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WAKEW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Tamper Module Enable"]
            #[inline]
            pub fn tpen(&self) -> TPENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TPENR { bits }
            }
            #[doc = "Bit 4 - Tamper Event Clear"]
            #[inline]
            pub fn tpclr(&self) -> TPCLRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TPCLRR { bits }
            }
            #[doc = "Bits 8:9 - HIB Memory Clear on Tamper Event"]
            #[inline]
            pub fn memclr(&self) -> MEMCLRR {
                MEMCLRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 11 - Wake from Hibernate on a Tamper Event"]
            #[inline]
            pub fn wake(&self) -> WAKER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WAKER { bits }
            }
        }
        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 = "Bit 0 - Tamper Module Enable"]
            #[inline]
            pub fn tpen(&mut self) -> _TPENW {
                _TPENW { w: self }
            }
            #[doc = "Bit 4 - Tamper Event Clear"]
            #[inline]
            pub fn tpclr(&mut self) -> _TPCLRW {
                _TPCLRW { w: self }
            }
            #[doc = "Bits 8:9 - HIB Memory Clear on Tamper Event"]
            #[inline]
            pub fn memclr(&mut self) -> _MEMCLRW {
                _MEMCLRW { w: self }
            }
            #[doc = "Bit 11 - Wake from Hibernate on a Tamper Event"]
            #[inline]
            pub fn wake(&mut self) -> _WAKEW {
                _WAKEW { w: self }
            }
        }
    }
    #[doc = "HIB Tamper Status"]
    pub struct TPSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Status"]
    pub mod tpstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TPSTAT {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCFAILR {
            bits: bool,
        }
        impl XOSCFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCSTR {
            bits: bool,
        }
        impl XOSCSTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `STATE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum STATER {
            #[doc = "Tamper disabled"]
            DISABLED,
            #[doc = "Tamper configured"]
            CONFIGED,
            #[doc = "Tamper pin event occurred"]
            ERROR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl STATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    STATER::DISABLED => 0,
                    STATER::CONFIGED => 0x01,
                    STATER::ERROR => 0x02,
                    STATER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> STATER {
                match value {
                    0 => STATER::DISABLED,
                    1 => STATER::CONFIGED,
                    2 => STATER::ERROR,
                    i => STATER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `DISABLED`"]
            #[inline]
            pub fn is_disabled(&self) -> bool {
                *self == STATER::DISABLED
            }
            #[doc = "Checks if the value of the field is `CONFIGED`"]
            #[inline]
            pub fn is_configed(&self) -> bool {
                *self == STATER::CONFIGED
            }
            #[doc = "Checks if the value of the field is `ERROR`"]
            #[inline]
            pub fn is_error(&self) -> bool {
                *self == STATER::ERROR
            }
        }
        #[doc = r" Proxy"]
        pub struct _XOSCFAILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XOSCFAILW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _XOSCSTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _XOSCSTW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `STATE`"]
        pub enum STATEW {
            #[doc = "Tamper disabled"]
            DISABLED,
            #[doc = "Tamper configured"]
            CONFIGED,
            #[doc = "Tamper pin event occurred"]
            ERROR,
        }
        impl STATEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    STATEW::DISABLED => 0,
                    STATEW::CONFIGED => 1,
                    STATEW::ERROR => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _STATEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _STATEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: STATEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Tamper disabled"]
            #[inline]
            pub fn disabled(self) -> &'a mut W {
                self.variant(STATEW::DISABLED)
            }
            #[doc = "Tamper configured"]
            #[inline]
            pub fn configed(self) -> &'a mut W {
                self.variant(STATEW::CONFIGED)
            }
            #[doc = "Tamper pin event occurred"]
            #[inline]
            pub fn error(self) -> &'a mut W {
                self.variant(STATEW::ERROR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - External Oscillator Failure"]
            #[inline]
            pub fn xoscfail(&self) -> XOSCFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCFAILR { bits }
            }
            #[doc = "Bit 1 - External Oscillator Status"]
            #[inline]
            pub fn xoscst(&self) -> XOSCSTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCSTR { bits }
            }
            #[doc = "Bits 2:3 - Tamper Module Status"]
            #[inline]
            pub fn state(&self) -> STATER {
                STATER::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 = "Bit 0 - External Oscillator Failure"]
            #[inline]
            pub fn xoscfail(&mut self) -> _XOSCFAILW {
                _XOSCFAILW { w: self }
            }
            #[doc = "Bit 1 - External Oscillator Status"]
            #[inline]
            pub fn xoscst(&mut self) -> _XOSCSTW {
                _XOSCSTW { w: self }
            }
            #[doc = "Bits 2:3 - Tamper Module Status"]
            #[inline]
            pub fn state(&mut self) -> _STATEW {
                _STATEW { w: self }
            }
        }
    }
    #[doc = "HIB Tamper I/O Control"]
    pub struct TPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper I/O Control"]
    pub mod tpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::TPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EN0R {
            bits: bool,
        }
        impl EN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LEV0R {
            bits: bool,
        }
        impl LEV0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PUEN0R {
            bits: bool,
        }
        impl PUEN0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GFLTR0R {
            bits: bool,
        }
        impl GFLTR0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EN1R {
            bits: bool,
        }
        impl EN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LEV1R {
            bits: bool,
        }
        impl LEV1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PUEN1R {
            bits: bool,
        }
        impl PUEN1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GFLTR1R {
            bits: bool,
        }
        impl GFLTR1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EN2R {
            bits: bool,
        }
        impl EN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LEV2R {
            bits: bool,
        }
        impl LEV2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PUEN2R {
            bits: bool,
        }
        impl PUEN2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GFLTR2R {
            bits: bool,
        }
        impl GFLTR2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EN3R {
            bits: bool,
        }
        impl EN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LEV3R {
            bits: bool,
        }
        impl LEV3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PUEN3R {
            bits: bool,
        }
        impl PUEN3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct GFLTR3R {
            bits: bool,
        }
        impl GFLTR3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EN0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _LEV0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _LEV0W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PUEN0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PUEN0W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GFLTR0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GFLTR0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EN1W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LEV1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _LEV1W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PUEN1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PUEN1W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GFLTR1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GFLTR1W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EN2W<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LEV2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _LEV2W<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PUEN2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PUEN2W<'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 = 18;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GFLTR2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GFLTR2W<'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 = 19;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _EN3W<'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 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LEV3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _LEV3W<'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 = 25;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PUEN3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _PUEN3W<'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 = 26;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _GFLTR3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _GFLTR3W<'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 = 27;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - TMPR0 Enable"]
            #[inline]
            pub fn en0(&self) -> EN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EN0R { bits }
            }
            #[doc = "Bit 1 - TMPR0 Trigger Level"]
            #[inline]
            pub fn lev0(&self) -> LEV0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LEV0R { bits }
            }
            #[doc = "Bit 2 - TMPR0 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen0(&self) -> PUEN0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PUEN0R { bits }
            }
            #[doc = "Bit 3 - TMPR0 Glitch Filtering"]
            #[inline]
            pub fn gfltr0(&self) -> GFLTR0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GFLTR0R { bits }
            }
            #[doc = "Bit 8 - TMPR1Enable"]
            #[inline]
            pub fn en1(&self) -> EN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EN1R { bits }
            }
            #[doc = "Bit 9 - TMPR1 Trigger Level"]
            #[inline]
            pub fn lev1(&self) -> LEV1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LEV1R { bits }
            }
            #[doc = "Bit 10 - TMPR1 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen1(&self) -> PUEN1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PUEN1R { bits }
            }
            #[doc = "Bit 11 - TMPR1 Glitch Filtering"]
            #[inline]
            pub fn gfltr1(&self) -> GFLTR1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GFLTR1R { bits }
            }
            #[doc = "Bit 16 - TMPR2 Enable"]
            #[inline]
            pub fn en2(&self) -> EN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EN2R { bits }
            }
            #[doc = "Bit 17 - TMPR2 Trigger Level"]
            #[inline]
            pub fn lev2(&self) -> LEV2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LEV2R { bits }
            }
            #[doc = "Bit 18 - TMPR2 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen2(&self) -> PUEN2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 18;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PUEN2R { bits }
            }
            #[doc = "Bit 19 - TMPR2 Glitch Filtering"]
            #[inline]
            pub fn gfltr2(&self) -> GFLTR2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GFLTR2R { bits }
            }
            #[doc = "Bit 24 - TMPR3 Enable"]
            #[inline]
            pub fn en3(&self) -> EN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EN3R { bits }
            }
            #[doc = "Bit 25 - TMPR3 Trigger Level"]
            #[inline]
            pub fn lev3(&self) -> LEV3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 25;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LEV3R { bits }
            }
            #[doc = "Bit 26 - TMPR3 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen3(&self) -> PUEN3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 26;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PUEN3R { bits }
            }
            #[doc = "Bit 27 - TMPR3 Glitch Filtering"]
            #[inline]
            pub fn gfltr3(&self) -> GFLTR3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 27;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                GFLTR3R { bits }
            }
        }
        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 = "Bit 0 - TMPR0 Enable"]
            #[inline]
            pub fn en0(&mut self) -> _EN0W {
                _EN0W { w: self }
            }
            #[doc = "Bit 1 - TMPR0 Trigger Level"]
            #[inline]
            pub fn lev0(&mut self) -> _LEV0W {
                _LEV0W { w: self }
            }
            #[doc = "Bit 2 - TMPR0 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen0(&mut self) -> _PUEN0W {
                _PUEN0W { w: self }
            }
            #[doc = "Bit 3 - TMPR0 Glitch Filtering"]
            #[inline]
            pub fn gfltr0(&mut self) -> _GFLTR0W {
                _GFLTR0W { w: self }
            }
            #[doc = "Bit 8 - TMPR1Enable"]
            #[inline]
            pub fn en1(&mut self) -> _EN1W {
                _EN1W { w: self }
            }
            #[doc = "Bit 9 - TMPR1 Trigger Level"]
            #[inline]
            pub fn lev1(&mut self) -> _LEV1W {
                _LEV1W { w: self }
            }
            #[doc = "Bit 10 - TMPR1 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen1(&mut self) -> _PUEN1W {
                _PUEN1W { w: self }
            }
            #[doc = "Bit 11 - TMPR1 Glitch Filtering"]
            #[inline]
            pub fn gfltr1(&mut self) -> _GFLTR1W {
                _GFLTR1W { w: self }
            }
            #[doc = "Bit 16 - TMPR2 Enable"]
            #[inline]
            pub fn en2(&mut self) -> _EN2W {
                _EN2W { w: self }
            }
            #[doc = "Bit 17 - TMPR2 Trigger Level"]
            #[inline]
            pub fn lev2(&mut self) -> _LEV2W {
                _LEV2W { w: self }
            }
            #[doc = "Bit 18 - TMPR2 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen2(&mut self) -> _PUEN2W {
                _PUEN2W { w: self }
            }
            #[doc = "Bit 19 - TMPR2 Glitch Filtering"]
            #[inline]
            pub fn gfltr2(&mut self) -> _GFLTR2W {
                _GFLTR2W { w: self }
            }
            #[doc = "Bit 24 - TMPR3 Enable"]
            #[inline]
            pub fn en3(&mut self) -> _EN3W {
                _EN3W { w: self }
            }
            #[doc = "Bit 25 - TMPR3 Trigger Level"]
            #[inline]
            pub fn lev3(&mut self) -> _LEV3W {
                _LEV3W { w: self }
            }
            #[doc = "Bit 26 - TMPR3 Internal Weak Pull-up Enable"]
            #[inline]
            pub fn puen3(&mut self) -> _PUEN3W {
                _PUEN3W { w: self }
            }
            #[doc = "Bit 27 - TMPR3 Glitch Filtering"]
            #[inline]
            pub fn gfltr3(&mut self) -> _GFLTR3W {
                _GFLTR3W { w: self }
            }
        }
    }
    #[doc = "HIB Tamper Log 0"]
    pub struct TPLOG0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 0"]
    pub mod tplog0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMER {
            bits: u32,
        }
        impl TIMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Tamper Log Calendar Information"]
            #[inline]
            pub fn time(&self) -> TIMER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TIMER { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 1"]
    pub struct TPLOG1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 1"]
    pub mod tplog1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG0R {
            bits: bool,
        }
        impl TRIG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG1R {
            bits: bool,
        }
        impl TRIG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG2R {
            bits: bool,
        }
        impl TRIG2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG3R {
            bits: bool,
        }
        impl TRIG3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCR {
            bits: bool,
        }
        impl XOSCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Status of TMPR[0] Trigger"]
            #[inline]
            pub fn trig0(&self) -> TRIG0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG0R { bits }
            }
            #[doc = "Bit 1 - Status of TMPR[1] Trigger"]
            #[inline]
            pub fn trig1(&self) -> TRIG1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG1R { bits }
            }
            #[doc = "Bit 2 - Status of TMPR[2] Trigger"]
            #[inline]
            pub fn trig2(&self) -> TRIG2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG2R { bits }
            }
            #[doc = "Bit 3 - Status of TMPR[3] Trigger"]
            #[inline]
            pub fn trig3(&self) -> TRIG3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG3R { bits }
            }
            #[doc = "Bit 16 - Status of external 32"]
            #[inline]
            pub fn xosc(&self) -> XOSCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCR { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 2"]
    pub struct TPLOG2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 2"]
    pub mod tplog2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG2 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMER {
            bits: u32,
        }
        impl TIMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Tamper Log Calendar Information"]
            #[inline]
            pub fn time(&self) -> TIMER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TIMER { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 3"]
    pub struct TPLOG3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 3"]
    pub mod tplog3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG3 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG0R {
            bits: bool,
        }
        impl TRIG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG1R {
            bits: bool,
        }
        impl TRIG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG2R {
            bits: bool,
        }
        impl TRIG2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG3R {
            bits: bool,
        }
        impl TRIG3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCR {
            bits: bool,
        }
        impl XOSCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Status of TMPR[0] Trigger"]
            #[inline]
            pub fn trig0(&self) -> TRIG0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG0R { bits }
            }
            #[doc = "Bit 1 - Status of TMPR[1] Trigger"]
            #[inline]
            pub fn trig1(&self) -> TRIG1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG1R { bits }
            }
            #[doc = "Bit 2 - Status of TMPR[2] Trigger"]
            #[inline]
            pub fn trig2(&self) -> TRIG2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG2R { bits }
            }
            #[doc = "Bit 3 - Status of TMPR[3] Trigger"]
            #[inline]
            pub fn trig3(&self) -> TRIG3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG3R { bits }
            }
            #[doc = "Bit 16 - Status of external 32"]
            #[inline]
            pub fn xosc(&self) -> XOSCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCR { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 4"]
    pub struct TPLOG4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 4"]
    pub mod tplog4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG4 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMER {
            bits: u32,
        }
        impl TIMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Tamper Log Calendar Information"]
            #[inline]
            pub fn time(&self) -> TIMER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TIMER { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 5"]
    pub struct TPLOG5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 5"]
    pub mod tplog5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG5 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG0R {
            bits: bool,
        }
        impl TRIG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG1R {
            bits: bool,
        }
        impl TRIG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG2R {
            bits: bool,
        }
        impl TRIG2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG3R {
            bits: bool,
        }
        impl TRIG3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCR {
            bits: bool,
        }
        impl XOSCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Status of TMPR[0] Trigger"]
            #[inline]
            pub fn trig0(&self) -> TRIG0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG0R { bits }
            }
            #[doc = "Bit 1 - Status of TMPR[1] Trigger"]
            #[inline]
            pub fn trig1(&self) -> TRIG1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG1R { bits }
            }
            #[doc = "Bit 2 - Status of TMPR[2] Trigger"]
            #[inline]
            pub fn trig2(&self) -> TRIG2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG2R { bits }
            }
            #[doc = "Bit 3 - Status of TMPR[3] Trigger"]
            #[inline]
            pub fn trig3(&self) -> TRIG3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG3R { bits }
            }
            #[doc = "Bit 16 - Status of external 32"]
            #[inline]
            pub fn xosc(&self) -> XOSCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCR { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 6"]
    pub struct TPLOG6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 6"]
    pub mod tplog6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG6 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TIMER {
            bits: u32,
        }
        impl TIMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Tamper Log Calendar Information"]
            #[inline]
            pub fn time(&self) -> TIMER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                TIMER { bits }
            }
        }
    }
    #[doc = "HIB Tamper Log 7"]
    pub struct TPLOG7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "HIB Tamper Log 7"]
    pub mod tplog7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::TPLOG7 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG0R {
            bits: bool,
        }
        impl TRIG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG1R {
            bits: bool,
        }
        impl TRIG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG2R {
            bits: bool,
        }
        impl TRIG2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TRIG3R {
            bits: bool,
        }
        impl TRIG3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct XOSCR {
            bits: bool,
        }
        impl XOSCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Status of TMPR[0] Trigger"]
            #[inline]
            pub fn trig0(&self) -> TRIG0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG0R { bits }
            }
            #[doc = "Bit 1 - Status of TMPR[1] Trigger"]
            #[inline]
            pub fn trig1(&self) -> TRIG1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG1R { bits }
            }
            #[doc = "Bit 2 - Status of TMPR[2] Trigger"]
            #[inline]
            pub fn trig2(&self) -> TRIG2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG2R { bits }
            }
            #[doc = "Bit 3 - Status of TMPR[3] Trigger"]
            #[inline]
            pub fn trig3(&self) -> TRIG3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TRIG3R { bits }
            }
            #[doc = "Bit 16 - Status of external 32"]
            #[inline]
            pub fn xosc(&self) -> XOSCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                XOSCR { bits }
            }
        }
    }
    #[doc = "Hibernation Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAKENCR {
            bits: bool,
        }
        impl WAKENCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMPERR {
            bits: bool,
        }
        impl TAMPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Wake Pin Presence"]
            #[inline]
            pub fn wakenc(&self) -> WAKENCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WAKENCR { bits }
            }
            #[doc = "Bit 1 - Tamper Pin Presence"]
            #[inline]
            pub fn tamper(&self) -> TAMPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMPERR { bits }
            }
        }
    }
    #[doc = "Hibernation Clock Control"]
    pub struct CC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Clock Control"]
    pub mod cc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SYSCLKENR {
            bits: bool,
        }
        impl SYSCLKENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _SYSCLKENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SYSCLKENW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTCOSC to System Clock Enable"]
            #[inline]
            pub fn sysclken(&self) -> SYSCLKENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SYSCLKENR { bits }
            }
        }
        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 = "Bit 0 - RTCOSC to System Clock Enable"]
            #[inline]
            pub fn sysclken(&mut self) -> _SYSCLKENW {
                _SYSCLKENW { w: self }
            }
        }
    }
}
#[doc = "FLASH register offsets"]
pub struct FLASH_CTRL {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for FLASH_CTRL {}
impl FLASH_CTRL {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const flash_ctrl::RegisterBlock {
        0x400f_d000 as *const _
    }
}
impl Deref for FLASH_CTRL {
    type Target = flash_ctrl::RegisterBlock;
    fn deref(&self) -> &flash_ctrl::RegisterBlock {
        unsafe { &*FLASH_CTRL::ptr() }
    }
}
#[doc = "FLASH register offsets"]
pub mod flash_ctrl {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Flash Memory Address"]
        pub fma: FMA,
        #[doc = "0x04 - Flash Memory Data"]
        pub fmd: FMD,
        #[doc = "0x08 - Flash Memory Control"]
        pub fmc: FMC,
        #[doc = "0x0c - Flash Controller Raw Interrupt Status"]
        pub fcris: FCRIS,
        #[doc = "0x10 - Flash Controller Interrupt Mask"]
        pub fcim: FCIM,
        #[doc = "0x14 - Flash Controller Masked Interrupt Status and Clear"]
        pub fcmisc: FCMISC,
        _reserved0: [u8; 8usize],
        #[doc = "0x20 - Flash Memory Control 2"]
        pub fmc2: FMC2,
        _reserved1: [u8; 12usize],
        #[doc = "0x30 - Flash Write Buffer Valid"]
        pub fwbval: FWBVAL,
        _reserved2: [u8; 8usize],
        #[doc = "0x3c - Flash Program/Erase Key"]
        pub flpekey: FLPEKEY,
        _reserved3: [u8; 192usize],
        #[doc = "0x100 - Flash Write Buffer n"]
        pub fwbn: FWBN,
        _reserved4: [u8; 3772usize],
        #[doc = "0xfc0 - Flash Peripheral Properties"]
        pub pp: PP,
        #[doc = "0xfc4 - SRAM Size"]
        pub ssize: SSIZE,
        #[doc = "0xfc8 - Flash Configuration Register"]
        pub conf: CONF,
        #[doc = "0xfcc - ROM Software Map"]
        pub romswmap: ROMSWMAP,
        #[doc = "0xfd0 - Flash DMA Address Size"]
        pub dmasz: DMASZ,
        #[doc = "0xfd4 - Flash DMA Starting Address"]
        pub dmast: DMAST,
        _reserved5: [u8; 252usize],
        #[doc = "0x10d4 - Reset Vector Pointer"]
        pub rvp: RVP,
        _reserved6: [u8; 248usize],
        #[doc = "0x11d0 - Boot Configuration"]
        pub bootcfg: BOOTCFG,
        _reserved7: [u8; 12usize],
        #[doc = "0x11e0 - User Register 0"]
        pub userreg0: USERREG0,
        #[doc = "0x11e4 - User Register 1"]
        pub userreg1: USERREG1,
        #[doc = "0x11e8 - User Register 2"]
        pub userreg2: USERREG2,
        #[doc = "0x11ec - User Register 3"]
        pub userreg3: USERREG3,
        _reserved8: [u8; 16usize],
        #[doc = "0x1200 - Flash Memory Protection Read Enable 0"]
        pub fmpre0: FMPRE0,
        #[doc = "0x1204 - Flash Memory Protection Read Enable 1"]
        pub fmpre1: FMPRE1,
        #[doc = "0x1208 - Flash Memory Protection Read Enable 2"]
        pub fmpre2: FMPRE2,
        #[doc = "0x120c - Flash Memory Protection Read Enable 3"]
        pub fmpre3: FMPRE3,
        #[doc = "0x1210 - Flash Memory Protection Read Enable 4"]
        pub fmpre4: FMPRE4,
        #[doc = "0x1214 - Flash Memory Protection Read Enable 5"]
        pub fmpre5: FMPRE5,
        #[doc = "0x1218 - Flash Memory Protection Read Enable 6"]
        pub fmpre6: FMPRE6,
        #[doc = "0x121c - Flash Memory Protection Read Enable 7"]
        pub fmpre7: FMPRE7,
        #[doc = "0x1220 - Flash Memory Protection Read Enable 8"]
        pub fmpre8: FMPRE8,
        #[doc = "0x1224 - Flash Memory Protection Read Enable 9"]
        pub fmpre9: FMPRE9,
        #[doc = "0x1228 - Flash Memory Protection Read Enable 10"]
        pub fmpre10: FMPRE10,
        #[doc = "0x122c - Flash Memory Protection Read Enable 11"]
        pub fmpre11: FMPRE11,
        #[doc = "0x1230 - Flash Memory Protection Read Enable 12"]
        pub fmpre12: FMPRE12,
        #[doc = "0x1234 - Flash Memory Protection Read Enable 13"]
        pub fmpre13: FMPRE13,
        #[doc = "0x1238 - Flash Memory Protection Read Enable 14"]
        pub fmpre14: FMPRE14,
        #[doc = "0x123c - Flash Memory Protection Read Enable 15"]
        pub fmpre15: FMPRE15,
        _reserved9: [u8; 448usize],
        #[doc = "0x1400 - Flash Memory Protection Program Enable 0"]
        pub fmppe0: FMPPE0,
        #[doc = "0x1404 - Flash Memory Protection Program Enable 1"]
        pub fmppe1: FMPPE1,
        #[doc = "0x1408 - Flash Memory Protection Program Enable 2"]
        pub fmppe2: FMPPE2,
        #[doc = "0x140c - Flash Memory Protection Program Enable 3"]
        pub fmppe3: FMPPE3,
        #[doc = "0x1410 - Flash Memory Protection Program Enable 4"]
        pub fmppe4: FMPPE4,
        #[doc = "0x1414 - Flash Memory Protection Program Enable 5"]
        pub fmppe5: FMPPE5,
        #[doc = "0x1418 - Flash Memory Protection Program Enable 6"]
        pub fmppe6: FMPPE6,
        #[doc = "0x141c - Flash Memory Protection Program Enable 7"]
        pub fmppe7: FMPPE7,
        #[doc = "0x1420 - Flash Memory Protection Program Enable 8"]
        pub fmppe8: FMPPE8,
        #[doc = "0x1424 - Flash Memory Protection Program Enable 9"]
        pub fmppe9: FMPPE9,
        #[doc = "0x1428 - Flash Memory Protection Program Enable 10"]
        pub fmppe10: FMPPE10,
        #[doc = "0x142c - Flash Memory Protection Program Enable 11"]
        pub fmppe11: FMPPE11,
        #[doc = "0x1430 - Flash Memory Protection Program Enable 12"]
        pub fmppe12: FMPPE12,
        #[doc = "0x1434 - Flash Memory Protection Program Enable 13"]
        pub fmppe13: FMPPE13,
        #[doc = "0x1438 - Flash Memory Protection Program Enable 14"]
        pub fmppe14: FMPPE14,
        #[doc = "0x143c - Flash Memory Protection Program Enable 15"]
        pub fmppe15: FMPPE15,
    }
    #[doc = "Flash Memory Address"]
    pub struct FMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Address"]
    pub mod fma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct OFFSETR {
            bits: u32,
        }
        impl OFFSETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _OFFSETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OFFSETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x000f_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:19 - Address Offset"]
            #[inline]
            pub fn offset(&self) -> OFFSETR {
                let bits = {
                    const MASK: u32 = 0x000f_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                OFFSETR { bits }
            }
        }
        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 0:19 - Address Offset"]
            #[inline]
            pub fn offset(&mut self) -> _OFFSETW {
                _OFFSETW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Data"]
    pub struct FMD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Data"]
    pub mod fmd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Data Value"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - Data Value"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Control"]
    pub struct FMC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Control"]
    pub mod fmc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRITER {
            bits: bool,
        }
        impl WRITER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERASER {
            bits: bool,
        }
        impl ERASER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MERASER {
            bits: bool,
        }
        impl MERASER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct COMTR {
            bits: bool,
        }
        impl COMTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRKEYR {
            bits: u16,
        }
        impl WRKEYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRITEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRITEW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERASEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERASEW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MERASEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MERASEW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _COMTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _COMTW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRKEYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRKEYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x7fff;
                const OFFSET: u8 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Write a Word into Flash Memory"]
            #[inline]
            pub fn write(&self) -> WRITER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRITER { bits }
            }
            #[doc = "Bit 1 - Erase a Page of Flash Memory"]
            #[inline]
            pub fn erase(&self) -> ERASER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERASER { bits }
            }
            #[doc = "Bit 2 - Mass Erase Flash Memory"]
            #[inline]
            pub fn merase(&self) -> MERASER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MERASER { bits }
            }
            #[doc = "Bit 3 - Commit Register Value"]
            #[inline]
            pub fn comt(&self) -> COMTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                COMTR { bits }
            }
            #[doc = "Bits 17:31 - FLASH write key"]
            #[inline]
            pub fn wrkey(&self) -> WRKEYR {
                let bits = {
                    const MASK: u16 = 0x7fff;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                WRKEYR { bits }
            }
        }
        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 = "Bit 0 - Write a Word into Flash Memory"]
            #[inline]
            pub fn write(&mut self) -> _WRITEW {
                _WRITEW { w: self }
            }
            #[doc = "Bit 1 - Erase a Page of Flash Memory"]
            #[inline]
            pub fn erase(&mut self) -> _ERASEW {
                _ERASEW { w: self }
            }
            #[doc = "Bit 2 - Mass Erase Flash Memory"]
            #[inline]
            pub fn merase(&mut self) -> _MERASEW {
                _MERASEW { w: self }
            }
            #[doc = "Bit 3 - Commit Register Value"]
            #[inline]
            pub fn comt(&mut self) -> _COMTW {
                _COMTW { w: self }
            }
            #[doc = "Bits 17:31 - FLASH write key"]
            #[inline]
            pub fn wrkey(&mut self) -> _WRKEYW {
                _WRKEYW { w: self }
            }
        }
    }
    #[doc = "Flash Controller Raw Interrupt Status"]
    pub struct FCRIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Controller Raw Interrupt Status"]
    pub mod fcris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::FCRIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ARISR {
            bits: bool,
        }
        impl ARISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PRISR {
            bits: bool,
        }
        impl PRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERISR {
            bits: bool,
        }
        impl ERISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VOLTRISR {
            bits: bool,
        }
        impl VOLTRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVDRISR {
            bits: bool,
        }
        impl INVDRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRISR {
            bits: bool,
        }
        impl ERRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROGRISR {
            bits: bool,
        }
        impl PROGRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Access Raw Interrupt Status"]
            #[inline]
            pub fn aris(&self) -> ARISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ARISR { bits }
            }
            #[doc = "Bit 1 - Programming Raw Interrupt Status"]
            #[inline]
            pub fn pris(&self) -> PRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PRISR { bits }
            }
            #[doc = "Bit 2 - EEPROM Raw Interrupt Status"]
            #[inline]
            pub fn eris(&self) -> ERISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERISR { bits }
            }
            #[doc = "Bit 9 - Pump Voltage Raw Interrupt Status"]
            #[inline]
            pub fn voltris(&self) -> VOLTRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VOLTRISR { bits }
            }
            #[doc = "Bit 10 - Invalid Data Raw Interrupt Status"]
            #[inline]
            pub fn invdris(&self) -> INVDRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVDRISR { bits }
            }
            #[doc = "Bit 11 - Erase Verify Error Raw Interrupt Status"]
            #[inline]
            pub fn erris(&self) -> ERRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRISR { bits }
            }
            #[doc = "Bit 13 - Program Verify Error Raw Interrupt Status"]
            #[inline]
            pub fn progris(&self) -> PROGRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PROGRISR { bits }
            }
        }
    }
    #[doc = "Flash Controller Interrupt Mask"]
    pub struct FCIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Controller Interrupt Mask"]
    pub mod fcim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FCIM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct AMASKR {
            bits: bool,
        }
        impl AMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMASKR {
            bits: bool,
        }
        impl PMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMASKR {
            bits: bool,
        }
        impl EMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VOLTMASKR {
            bits: bool,
        }
        impl VOLTMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVDMASKR {
            bits: bool,
        }
        impl INVDMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERMASKR {
            bits: bool,
        }
        impl ERMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROGMASKR {
            bits: bool,
        }
        impl PROGMASKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _AMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AMASKW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMASKW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMASKW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VOLTMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VOLTMASKW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INVDMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INVDMASKW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERMASKW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROGMASKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROGMASKW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Access Interrupt Mask"]
            #[inline]
            pub fn amask(&self) -> AMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AMASKR { bits }
            }
            #[doc = "Bit 1 - Programming Interrupt Mask"]
            #[inline]
            pub fn pmask(&self) -> PMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMASKR { bits }
            }
            #[doc = "Bit 2 - EEPROM Interrupt Mask"]
            #[inline]
            pub fn emask(&self) -> EMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMASKR { bits }
            }
            #[doc = "Bit 9 - VOLT Interrupt Mask"]
            #[inline]
            pub fn voltmask(&self) -> VOLTMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VOLTMASKR { bits }
            }
            #[doc = "Bit 10 - Invalid Data Interrupt Mask"]
            #[inline]
            pub fn invdmask(&self) -> INVDMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVDMASKR { bits }
            }
            #[doc = "Bit 11 - ERVER Interrupt Mask"]
            #[inline]
            pub fn ermask(&self) -> ERMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERMASKR { bits }
            }
            #[doc = "Bit 13 - PROGVER Interrupt Mask"]
            #[inline]
            pub fn progmask(&self) -> PROGMASKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PROGMASKR { bits }
            }
        }
        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 = "Bit 0 - Access Interrupt Mask"]
            #[inline]
            pub fn amask(&mut self) -> _AMASKW {
                _AMASKW { w: self }
            }
            #[doc = "Bit 1 - Programming Interrupt Mask"]
            #[inline]
            pub fn pmask(&mut self) -> _PMASKW {
                _PMASKW { w: self }
            }
            #[doc = "Bit 2 - EEPROM Interrupt Mask"]
            #[inline]
            pub fn emask(&mut self) -> _EMASKW {
                _EMASKW { w: self }
            }
            #[doc = "Bit 9 - VOLT Interrupt Mask"]
            #[inline]
            pub fn voltmask(&mut self) -> _VOLTMASKW {
                _VOLTMASKW { w: self }
            }
            #[doc = "Bit 10 - Invalid Data Interrupt Mask"]
            #[inline]
            pub fn invdmask(&mut self) -> _INVDMASKW {
                _INVDMASKW { w: self }
            }
            #[doc = "Bit 11 - ERVER Interrupt Mask"]
            #[inline]
            pub fn ermask(&mut self) -> _ERMASKW {
                _ERMASKW { w: self }
            }
            #[doc = "Bit 13 - PROGVER Interrupt Mask"]
            #[inline]
            pub fn progmask(&mut self) -> _PROGMASKW {
                _PROGMASKW { w: self }
            }
        }
    }
    #[doc = "Flash Controller Masked Interrupt Status and Clear"]
    pub struct FCMISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Controller Masked Interrupt Status and Clear"]
    pub mod fcmisc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FCMISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct AMISCR {
            bits: bool,
        }
        impl AMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PMISCR {
            bits: bool,
        }
        impl PMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct EMISCR {
            bits: bool,
        }
        impl EMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VOLTMISCR {
            bits: bool,
        }
        impl VOLTMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct INVDMISCR {
            bits: bool,
        }
        impl INVDMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERMISCR {
            bits: bool,
        }
        impl ERMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROGMISCR {
            bits: bool,
        }
        impl PROGMISCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _AMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _AMISCW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PMISCW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EMISCW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VOLTMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VOLTMISCW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _INVDMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INVDMISCW<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERMISCW<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROGMISCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROGMISCW<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Access Masked Interrupt Status and Clear"]
            #[inline]
            pub fn amisc(&self) -> AMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                AMISCR { bits }
            }
            #[doc = "Bit 1 - Programming Masked Interrupt Status and Clear"]
            #[inline]
            pub fn pmisc(&self) -> PMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PMISCR { bits }
            }
            #[doc = "Bit 2 - EEPROM Masked Interrupt Status and Clear"]
            #[inline]
            pub fn emisc(&self) -> EMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EMISCR { bits }
            }
            #[doc = "Bit 9 - VOLT Masked Interrupt Status and Clear"]
            #[inline]
            pub fn voltmisc(&self) -> VOLTMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VOLTMISCR { bits }
            }
            #[doc = "Bit 10 - Invalid Data Masked Interrupt Status and Clear"]
            #[inline]
            pub fn invdmisc(&self) -> INVDMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                INVDMISCR { bits }
            }
            #[doc = "Bit 11 - ERVER Masked Interrupt Status and Clear"]
            #[inline]
            pub fn ermisc(&self) -> ERMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERMISCR { bits }
            }
            #[doc = "Bit 13 - PROGVER Masked Interrupt Status and Clear"]
            #[inline]
            pub fn progmisc(&self) -> PROGMISCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PROGMISCR { bits }
            }
        }
        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 = "Bit 0 - Access Masked Interrupt Status and Clear"]
            #[inline]
            pub fn amisc(&mut self) -> _AMISCW {
                _AMISCW { w: self }
            }
            #[doc = "Bit 1 - Programming Masked Interrupt Status and Clear"]
            #[inline]
            pub fn pmisc(&mut self) -> _PMISCW {
                _PMISCW { w: self }
            }
            #[doc = "Bit 2 - EEPROM Masked Interrupt Status and Clear"]
            #[inline]
            pub fn emisc(&mut self) -> _EMISCW {
                _EMISCW { w: self }
            }
            #[doc = "Bit 9 - VOLT Masked Interrupt Status and Clear"]
            #[inline]
            pub fn voltmisc(&mut self) -> _VOLTMISCW {
                _VOLTMISCW { w: self }
            }
            #[doc = "Bit 10 - Invalid Data Masked Interrupt Status and Clear"]
            #[inline]
            pub fn invdmisc(&mut self) -> _INVDMISCW {
                _INVDMISCW { w: self }
            }
            #[doc = "Bit 11 - ERVER Masked Interrupt Status and Clear"]
            #[inline]
            pub fn ermisc(&mut self) -> _ERMISCW {
                _ERMISCW { w: self }
            }
            #[doc = "Bit 13 - PROGVER Masked Interrupt Status and Clear"]
            #[inline]
            pub fn progmisc(&mut self) -> _PROGMISCW {
                _PROGMISCW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Control 2"]
    pub struct FMC2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Control 2"]
    pub mod fmc2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMC2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct WRBUFR {
            bits: bool,
        }
        impl WRBUFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _WRBUFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _WRBUFW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Buffered Flash Memory Write"]
            #[inline]
            pub fn wrbuf(&self) -> WRBUFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WRBUFR { bits }
            }
        }
        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 = "Bit 0 - Buffered Flash Memory Write"]
            #[inline]
            pub fn wrbuf(&mut self) -> _WRBUFW {
                _WRBUFW { w: self }
            }
        }
    }
    #[doc = "Flash Write Buffer Valid"]
    pub struct FWBVAL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Write Buffer Valid"]
    pub mod fwbval {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FWBVAL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FWBR {
            bits: u32,
        }
        impl FWBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _FWBW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FWBW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Memory Write Buffer"]
            #[inline]
            pub fn fwb(&self) -> FWBR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                FWBR { bits }
            }
        }
        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 0:31 - Flash Memory Write Buffer"]
            #[inline]
            pub fn fwb(&mut self) -> _FWBW {
                _FWBW { w: self }
            }
        }
    }
    #[doc = "Flash Program/Erase Key"]
    pub struct FLPEKEY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Program/Erase Key"]
    pub mod flpekey {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FLPEKEY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PEKEYR {
            bits: u16,
        }
        impl PEKEYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PEKEYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PEKEYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0xffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Key Value"]
            #[inline]
            pub fn pekey(&self) -> PEKEYR {
                let bits = {
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                PEKEYR { bits }
            }
        }
        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 0:15 - Key Value"]
            #[inline]
            pub fn pekey(&mut self) -> _PEKEYW {
                _PEKEYW { w: self }
            }
        }
    }
    #[doc = "Flash Write Buffer n"]
    pub struct FWBN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Write Buffer n"]
    pub mod fwbn {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FWBN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "Flash Peripheral Properties"]
    pub struct PP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Peripheral Properties"]
    pub mod pp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "1024 KB of Flash"]
            _1MB,
            #[doc = r" Reserved"]
            _Reserved(u16),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                match *self {
                    SIZER::_1MB => 0x01ff,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u16) -> SIZER {
                match value {
                    511 => SIZER::_1MB,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1MB`"]
            #[inline]
            pub fn is_1mb(&self) -> bool {
                *self == SIZER::_1MB
            }
        }
        #[doc = "Possible values of the field `MAINSS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MAINSSR {
            #[doc = "1 KB"]
            _1KB,
            #[doc = "2 KB"]
            _2KB,
            #[doc = "4 KB"]
            _4KB,
            #[doc = "8 KB"]
            _8KB,
            #[doc = "16 KB"]
            _16KB,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MAINSSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MAINSSR::_1KB => 0,
                    MAINSSR::_2KB => 0x01,
                    MAINSSR::_4KB => 0x02,
                    MAINSSR::_8KB => 0x03,
                    MAINSSR::_16KB => 0x04,
                    MAINSSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MAINSSR {
                match value {
                    0 => MAINSSR::_1KB,
                    1 => MAINSSR::_2KB,
                    2 => MAINSSR::_4KB,
                    3 => MAINSSR::_8KB,
                    4 => MAINSSR::_16KB,
                    i => MAINSSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == MAINSSR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == MAINSSR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == MAINSSR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == MAINSSR::_8KB
            }
            #[doc = "Checks if the value of the field is `_16KB`"]
            #[inline]
            pub fn is_16kb(&self) -> bool {
                *self == MAINSSR::_16KB
            }
        }
        #[doc = "Possible values of the field `EESS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EESSR {
            #[doc = "1 KB"]
            _1KB,
            #[doc = "2 KB"]
            _2KB,
            #[doc = "4 KB"]
            _4KB,
            #[doc = "8 KB"]
            _8KB,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EESSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EESSR::_1KB => 0,
                    EESSR::_2KB => 0x01,
                    EESSR::_4KB => 0x02,
                    EESSR::_8KB => 0x03,
                    EESSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EESSR {
                match value {
                    0 => EESSR::_1KB,
                    1 => EESSR::_2KB,
                    2 => EESSR::_4KB,
                    3 => EESSR::_8KB,
                    i => EESSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1KB`"]
            #[inline]
            pub fn is_1kb(&self) -> bool {
                *self == EESSR::_1KB
            }
            #[doc = "Checks if the value of the field is `_2KB`"]
            #[inline]
            pub fn is_2kb(&self) -> bool {
                *self == EESSR::_2KB
            }
            #[doc = "Checks if the value of the field is `_4KB`"]
            #[inline]
            pub fn is_4kb(&self) -> bool {
                *self == EESSR::_4KB
            }
            #[doc = "Checks if the value of the field is `_8KB`"]
            #[inline]
            pub fn is_8kb(&self) -> bool {
                *self == EESSR::_8KB
            }
        }
        #[doc = r" Value of the field"]
        pub struct DFAR {
            bits: bool,
        }
        impl DFAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FMMR {
            bits: bool,
        }
        impl FMMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PFCR {
            bits: bool,
        }
        impl PFCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - Flash Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                })
            }
            #[doc = "Bits 16:18 - Flash Sector Size of the physical bank"]
            #[inline]
            pub fn mainss(&self) -> MAINSSR {
                MAINSSR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 19:22 - EEPROM Sector Size of the physical bank"]
            #[inline]
            pub fn eess(&self) -> EESSR {
                EESSR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 19;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 28 - DMA Flash Access"]
            #[inline]
            pub fn dfa(&self) -> DFAR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DFAR { bits }
            }
            #[doc = "Bit 29 - Flash Mirror Mode"]
            #[inline]
            pub fn fmm(&self) -> FMMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FMMR { bits }
            }
            #[doc = "Bit 30 - Prefetch Buffer Mode"]
            #[inline]
            pub fn pfc(&self) -> PFCR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PFCR { bits }
            }
        }
    }
    #[doc = "SRAM Size"]
    pub struct SSIZE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "SRAM Size"]
    pub mod ssize {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SSIZE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `SIZE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SIZER {
            #[doc = "256 KB of SRAM"]
            _256KB,
            #[doc = r" Reserved"]
            _Reserved(u16),
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                match *self {
                    SIZER::_256KB => 0x03ff,
                    SIZER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u16) -> SIZER {
                match value {
                    1023 => SIZER::_256KB,
                    i => SIZER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_256KB`"]
            #[inline]
            pub fn is_256kb(&self) -> bool {
                *self == SIZER::_256KB
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:15 - SRAM Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                SIZER::_from({
                    const MASK: u16 = 0xffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                })
            }
        }
    }
    #[doc = "Flash Configuration Register"]
    pub struct CONF {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Configuration Register"]
    pub mod conf {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CONF {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPFOFFR {
            bits: bool,
        }
        impl FPFOFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPFONR {
            bits: bool,
        }
        impl FPFONR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CLRTVR {
            bits: bool,
        }
        impl CLRTVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SPFER {
            bits: bool,
        }
        impl SPFER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct FMMER {
            bits: bool,
        }
        impl FMMER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPFOFFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPFOFFW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FPFONW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FPFONW<'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 = 17;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CLRTVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRTVW<'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 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SPFEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SPFEW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FMMEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FMMEW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 16 - Force Prefetch Off"]
            #[inline]
            pub fn fpfoff(&self) -> FPFOFFR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPFOFFR { bits }
            }
            #[doc = "Bit 17 - Force Prefetch On"]
            #[inline]
            pub fn fpfon(&self) -> FPFONR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 17;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPFONR { bits }
            }
            #[doc = "Bit 20 - Clear Valid Tags"]
            #[inline]
            pub fn clrtv(&self) -> CLRTVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CLRTVR { bits }
            }
            #[doc = "Bit 29 - Single Prefetch Mode Enable"]
            #[inline]
            pub fn spfe(&self) -> SPFER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SPFER { bits }
            }
            #[doc = "Bit 30 - Flash Mirror Mode Enable"]
            #[inline]
            pub fn fmme(&self) -> FMMER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FMMER { bits }
            }
        }
        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 = "Bit 16 - Force Prefetch Off"]
            #[inline]
            pub fn fpfoff(&mut self) -> _FPFOFFW {
                _FPFOFFW { w: self }
            }
            #[doc = "Bit 17 - Force Prefetch On"]
            #[inline]
            pub fn fpfon(&mut self) -> _FPFONW {
                _FPFONW { w: self }
            }
            #[doc = "Bit 20 - Clear Valid Tags"]
            #[inline]
            pub fn clrtv(&mut self) -> _CLRTVW {
                _CLRTVW { w: self }
            }
            #[doc = "Bit 29 - Single Prefetch Mode Enable"]
            #[inline]
            pub fn spfe(&mut self) -> _SPFEW {
                _SPFEW { w: self }
            }
            #[doc = "Bit 30 - Flash Mirror Mode Enable"]
            #[inline]
            pub fn fmme(&mut self) -> _FMMEW {
                _FMMEW { w: self }
            }
        }
    }
    #[doc = "ROM Software Map"]
    pub struct ROMSWMAP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "ROM Software Map"]
    pub mod romswmap {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ROMSWMAP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `SW0EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW0ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW0ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW0ENR::NOTVIS => 0,
                    SW0ENR::CORE => 0x01,
                    SW0ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW0ENR {
                match value {
                    0 => SW0ENR::NOTVIS,
                    1 => SW0ENR::CORE,
                    i => SW0ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW0ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW0ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW1EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW1ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW1ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW1ENR::NOTVIS => 0,
                    SW1ENR::CORE => 0x01,
                    SW1ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW1ENR {
                match value {
                    0 => SW1ENR::NOTVIS,
                    1 => SW1ENR::CORE,
                    i => SW1ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW1ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW1ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW2EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW2ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW2ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW2ENR::NOTVIS => 0,
                    SW2ENR::CORE => 0x01,
                    SW2ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW2ENR {
                match value {
                    0 => SW2ENR::NOTVIS,
                    1 => SW2ENR::CORE,
                    i => SW2ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW2ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW2ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW3EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW3ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW3ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW3ENR::NOTVIS => 0,
                    SW3ENR::CORE => 0x01,
                    SW3ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW3ENR {
                match value {
                    0 => SW3ENR::NOTVIS,
                    1 => SW3ENR::CORE,
                    i => SW3ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW3ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW3ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW4EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW4ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW4ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW4ENR::NOTVIS => 0,
                    SW4ENR::CORE => 0x01,
                    SW4ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW4ENR {
                match value {
                    0 => SW4ENR::NOTVIS,
                    1 => SW4ENR::CORE,
                    i => SW4ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW4ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW4ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW5EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW5ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW5ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW5ENR::NOTVIS => 0,
                    SW5ENR::CORE => 0x01,
                    SW5ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW5ENR {
                match value {
                    0 => SW5ENR::NOTVIS,
                    1 => SW5ENR::CORE,
                    i => SW5ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW5ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW5ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW6EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW6ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW6ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW6ENR::NOTVIS => 0,
                    SW6ENR::CORE => 0x01,
                    SW6ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW6ENR {
                match value {
                    0 => SW6ENR::NOTVIS,
                    1 => SW6ENR::CORE,
                    i => SW6ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW6ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW6ENR::CORE
            }
        }
        #[doc = "Possible values of the field `SW7EN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SW7ENR {
            #[doc = "Software region not available to the core"]
            NOTVIS,
            #[doc = "Region available to core"]
            CORE,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SW7ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SW7ENR::NOTVIS => 0,
                    SW7ENR::CORE => 0x01,
                    SW7ENR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SW7ENR {
                match value {
                    0 => SW7ENR::NOTVIS,
                    1 => SW7ENR::CORE,
                    i => SW7ENR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NOTVIS`"]
            #[inline]
            pub fn is_notvis(&self) -> bool {
                *self == SW7ENR::NOTVIS
            }
            #[doc = "Checks if the value of the field is `CORE`"]
            #[inline]
            pub fn is_core(&self) -> bool {
                *self == SW7ENR::CORE
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - ROM SW Region 0 Availability"]
            #[inline]
            pub fn sw0en(&self) -> SW0ENR {
                SW0ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - ROM SW Region 1 Availability"]
            #[inline]
            pub fn sw1en(&self) -> SW1ENR {
                SW1ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - ROM SW Region 2 Availability"]
            #[inline]
            pub fn sw2en(&self) -> SW2ENR {
                SW2ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - ROM SW Region 3 Availability"]
            #[inline]
            pub fn sw3en(&self) -> SW3ENR {
                SW3ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - ROM SW Region 4 Availability"]
            #[inline]
            pub fn sw4en(&self) -> SW4ENR {
                SW4ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 10:11 - ROM SW Region 5 Availability"]
            #[inline]
            pub fn sw5en(&self) -> SW5ENR {
                SW5ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 12:13 - ROM SW Region 6 Availability"]
            #[inline]
            pub fn sw6en(&self) -> SW6ENR {
                SW6ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 14:15 - ROM SW Region 7 Availability"]
            #[inline]
            pub fn sw7en(&self) -> SW7ENR {
                SW7ENR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
    }
    #[doc = "Flash DMA Address Size"]
    pub struct DMASZ {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash DMA Address Size"]
    pub mod dmasz {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMASZ {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIZER {
            bits: u32,
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x0003_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:17 - uDMA-accessible Memory Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                let bits = {
                    const MASK: u32 = 0x0003_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SIZER { bits }
            }
        }
        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 0:17 - uDMA-accessible Memory Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
        }
    }
    #[doc = "Flash DMA Starting Address"]
    pub struct DMAST {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash DMA Starting Address"]
    pub mod dmast {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DMAST {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x0003_ffff;
                const OFFSET: u8 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 11:28 - Contains the starting address of the flash region accessible by uDMA if the FLASHPP register DFA bit is set"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x0003_ffff;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 11:28 - Contains the starting address of the flash region accessible by uDMA if the FLASHPP register DFA bit is set"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "Reset Vector Pointer"]
    pub struct RVP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Reset Vector Pointer"]
    pub mod rvp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RVP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct RVR {
            bits: u32,
        }
        impl RVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _RVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Reset Vector Pointer Address"]
            #[inline]
            pub fn rv(&self) -> RVR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RVR { bits }
            }
        }
        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 0:31 - Reset Vector Pointer Address"]
            #[inline]
            pub fn rv(&mut self) -> _RVW {
                _RVW { w: self }
            }
        }
    }
    #[doc = "Boot Configuration"]
    pub struct BOOTCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Boot Configuration"]
    pub mod bootcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::BOOTCFG {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct DBG0R {
            bits: bool,
        }
        impl DBG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct DBG1R {
            bits: bool,
        }
        impl DBG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct KEYR {
            bits: bool,
        }
        impl KEYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENR {
            bits: bool,
        }
        impl ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct POLR {
            bits: bool,
        }
        impl POLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PIN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PINR {
            #[doc = "Pin 0"]
            _0,
            #[doc = "Pin 1"]
            _1,
            #[doc = "Pin 2"]
            _2,
            #[doc = "Pin 3"]
            _3,
            #[doc = "Pin 4"]
            _4,
            #[doc = "Pin 5"]
            _5,
            #[doc = "Pin 6"]
            _6,
            #[doc = "Pin 7"]
            _7,
        }
        impl PINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PINR::_0 => 0,
                    PINR::_1 => 0x01,
                    PINR::_2 => 0x02,
                    PINR::_3 => 0x03,
                    PINR::_4 => 0x04,
                    PINR::_5 => 0x05,
                    PINR::_6 => 0x06,
                    PINR::_7 => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PINR {
                match value {
                    0 => PINR::_0,
                    1 => PINR::_1,
                    2 => PINR::_2,
                    3 => PINR::_3,
                    4 => PINR::_4,
                    5 => PINR::_5,
                    6 => PINR::_6,
                    7 => PINR::_7,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == PINR::_0
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == PINR::_1
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == PINR::_2
            }
            #[doc = "Checks if the value of the field is `_3`"]
            #[inline]
            pub fn is_3(&self) -> bool {
                *self == PINR::_3
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == PINR::_4
            }
            #[doc = "Checks if the value of the field is `_5`"]
            #[inline]
            pub fn is_5(&self) -> bool {
                *self == PINR::_5
            }
            #[doc = "Checks if the value of the field is `_6`"]
            #[inline]
            pub fn is_6(&self) -> bool {
                *self == PINR::_6
            }
            #[doc = "Checks if the value of the field is `_7`"]
            #[inline]
            pub fn is_7(&self) -> bool {
                *self == PINR::_7
            }
        }
        #[doc = "Possible values of the field `PORT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PORTR {
            #[doc = "Port A"]
            A,
            #[doc = "Port B"]
            B,
            #[doc = "Port C"]
            C,
            #[doc = "Port D"]
            D,
            #[doc = "Port E"]
            E,
            #[doc = "Port F"]
            F,
            #[doc = "Port G"]
            G,
            #[doc = "Port H"]
            H,
        }
        impl PORTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PORTR::A => 0,
                    PORTR::B => 0x01,
                    PORTR::C => 0x02,
                    PORTR::D => 0x03,
                    PORTR::E => 0x04,
                    PORTR::F => 0x05,
                    PORTR::G => 0x06,
                    PORTR::H => 0x07,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PORTR {
                match value {
                    0 => PORTR::A,
                    1 => PORTR::B,
                    2 => PORTR::C,
                    3 => PORTR::D,
                    4 => PORTR::E,
                    5 => PORTR::F,
                    6 => PORTR::G,
                    7 => PORTR::H,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `A`"]
            #[inline]
            pub fn is_a(&self) -> bool {
                *self == PORTR::A
            }
            #[doc = "Checks if the value of the field is `B`"]
            #[inline]
            pub fn is_b(&self) -> bool {
                *self == PORTR::B
            }
            #[doc = "Checks if the value of the field is `C`"]
            #[inline]
            pub fn is_c(&self) -> bool {
                *self == PORTR::C
            }
            #[doc = "Checks if the value of the field is `D`"]
            #[inline]
            pub fn is_d(&self) -> bool {
                *self == PORTR::D
            }
            #[doc = "Checks if the value of the field is `E`"]
            #[inline]
            pub fn is_e(&self) -> bool {
                *self == PORTR::E
            }
            #[doc = "Checks if the value of the field is `F`"]
            #[inline]
            pub fn is_f(&self) -> bool {
                *self == PORTR::F
            }
            #[doc = "Checks if the value of the field is `G`"]
            #[inline]
            pub fn is_g(&self) -> bool {
                *self == PORTR::G
            }
            #[doc = "Checks if the value of the field is `H`"]
            #[inline]
            pub fn is_h(&self) -> bool {
                *self == PORTR::H
            }
        }
        #[doc = r" Value of the field"]
        pub struct NWR {
            bits: bool,
        }
        impl NWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Debug Control 0"]
            #[inline]
            pub fn dbg0(&self) -> DBG0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DBG0R { bits }
            }
            #[doc = "Bit 1 - Debug Control 1"]
            #[inline]
            pub fn dbg1(&self) -> DBG1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                DBG1R { bits }
            }
            #[doc = "Bit 4 - KEY Select"]
            #[inline]
            pub fn key(&self) -> KEYR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                KEYR { bits }
            }
            #[doc = "Bit 8 - Boot GPIO Enable"]
            #[inline]
            pub fn en(&self) -> ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENR { bits }
            }
            #[doc = "Bit 9 - Boot GPIO Polarity"]
            #[inline]
            pub fn pol(&self) -> POLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                POLR { bits }
            }
            #[doc = "Bits 10:12 - Boot GPIO Pin"]
            #[inline]
            pub fn pin(&self) -> PINR {
                PINR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 13:15 - Boot GPIO Port"]
            #[inline]
            pub fn port(&self) -> PORTR {
                PORTR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 31 - Not Written"]
            #[inline]
            pub fn nw(&self) -> NWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NWR { bits }
            }
        }
    }
    #[doc = "User Register 0"]
    pub struct USERREG0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "User Register 0"]
    pub mod userreg0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USERREG0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - User Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - User Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "User Register 1"]
    pub struct USERREG1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "User Register 1"]
    pub mod userreg1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USERREG1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - User Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - User Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "User Register 2"]
    pub struct USERREG2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "User Register 2"]
    pub mod userreg2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USERREG2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - User Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - User Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "User Register 3"]
    pub struct USERREG3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "User Register 3"]
    pub mod userreg3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USERREG3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAR {
            bits: u32,
        }
        impl DATAR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - User Data"]
            #[inline]
            pub fn data(&self) -> DATAR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAR { bits }
            }
        }
        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 0:31 - User Data"]
            #[inline]
            pub fn data(&mut self) -> _DATAW {
                _DATAW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 0"]
    pub struct FMPRE0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 0"]
    pub mod fmpre0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 1"]
    pub struct FMPRE1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 1"]
    pub mod fmpre1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 2"]
    pub struct FMPRE2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 2"]
    pub mod fmpre2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 3"]
    pub struct FMPRE3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 3"]
    pub mod fmpre3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 4"]
    pub struct FMPRE4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 4"]
    pub mod fmpre4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 5"]
    pub struct FMPRE5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 5"]
    pub mod fmpre5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 6"]
    pub struct FMPRE6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 6"]
    pub mod fmpre6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 7"]
    pub struct FMPRE7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 7"]
    pub mod fmpre7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Read Enable 8"]
    pub struct FMPRE8 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 8"]
    pub mod fmpre8 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE8 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 9"]
    pub struct FMPRE9 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 9"]
    pub mod fmpre9 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE9 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 10"]
    pub struct FMPRE10 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 10"]
    pub mod fmpre10 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE10 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 11"]
    pub struct FMPRE11 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 11"]
    pub mod fmpre11 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE11 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 12"]
    pub struct FMPRE12 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 12"]
    pub mod fmpre12 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE12 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 13"]
    pub struct FMPRE13 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 13"]
    pub mod fmpre13 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE13 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 14"]
    pub struct FMPRE14 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 14"]
    pub mod fmpre14 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE14 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Read Enable 15"]
    pub struct FMPRE15 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Read Enable 15"]
    pub mod fmpre15 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPRE15 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct READ_ENABLER {
            bits: u32,
        }
        impl READ_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _READ_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _READ_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&self) -> READ_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                READ_ENABLER { bits }
            }
        }
        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 0:31 - Flash Read Enable"]
            #[inline]
            pub fn read_enable(&mut self) -> _READ_ENABLEW {
                _READ_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 0"]
    pub struct FMPPE0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 0"]
    pub mod fmppe0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 1"]
    pub struct FMPPE1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 1"]
    pub mod fmppe1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 2"]
    pub struct FMPPE2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 2"]
    pub mod fmppe2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 3"]
    pub struct FMPPE3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 3"]
    pub mod fmppe3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 4"]
    pub struct FMPPE4 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 4"]
    pub mod fmppe4 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE4 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 5"]
    pub struct FMPPE5 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 5"]
    pub mod fmppe5 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE5 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 6"]
    pub struct FMPPE6 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 6"]
    pub mod fmppe6 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE6 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 7"]
    pub struct FMPPE7 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 7"]
    pub mod fmppe7 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE7 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        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 = "Flash Memory Protection Program Enable 8"]
    pub struct FMPPE8 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 8"]
    pub mod fmppe8 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE8 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 9"]
    pub struct FMPPE9 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 9"]
    pub mod fmppe9 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE9 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 10"]
    pub struct FMPPE10 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 10"]
    pub mod fmppe10 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE10 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 11"]
    pub struct FMPPE11 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 11"]
    pub mod fmppe11 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE11 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 12"]
    pub struct FMPPE12 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 12"]
    pub mod fmppe12 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE12 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 13"]
    pub struct FMPPE13 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 13"]
    pub mod fmppe13 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE13 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 14"]
    pub struct FMPPE14 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 14"]
    pub mod fmppe14 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE14 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
    #[doc = "Flash Memory Protection Program Enable 15"]
    pub struct FMPPE15 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Flash Memory Protection Program Enable 15"]
    pub mod fmppe15 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::FMPPE15 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PROG_ENABLER {
            bits: u32,
        }
        impl PROG_ENABLER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _PROG_ENABLEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PROG_ENABLEW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&self) -> PROG_ENABLER {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                PROG_ENABLER { bits }
            }
        }
        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 0:31 - Flash Programming Enable"]
            #[inline]
            pub fn prog_enable(&mut self) -> _PROG_ENABLEW {
                _PROG_ENABLEW { w: self }
            }
        }
    }
}
#[doc = "System Control register addresses"]
pub struct SYSCTL {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for SYSCTL {}
impl SYSCTL {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const sysctl::RegisterBlock {
        0x400f_e000 as *const _
    }
}
impl Deref for SYSCTL {
    type Target = sysctl::RegisterBlock;
    fn deref(&self) -> &sysctl::RegisterBlock {
        unsafe { &*SYSCTL::ptr() }
    }
}
#[doc = "System Control register addresses"]
pub mod sysctl {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - Device Identification 0"]
        pub did0: DID0,
        #[doc = "0x04 - Device Identification 1"]
        pub did1: DID1,
        _reserved0: [u8; 48usize],
        #[doc = "0x38 - Power-Temp Brown Out Control"]
        pub ptboctl: PTBOCTL,
        _reserved1: [u8; 20usize],
        #[doc = "0x50 - Raw Interrupt Status"]
        pub ris: RIS,
        #[doc = "0x54 - Interrupt Mask Control"]
        pub imc: IMC,
        #[doc = "0x58 - Masked Interrupt Status and Clear"]
        pub misc: MISC,
        #[doc = "0x5c - Reset Cause"]
        pub resc: RESC,
        #[doc = "0x60 - Power-Temperature Cause"]
        pub pwrtc: PWRTC,
        #[doc = "0x64 - NMI Cause Register"]
        pub nmic: NMIC,
        _reserved2: [u8; 20usize],
        #[doc = "0x7c - Main Oscillator Control"]
        pub moscctl: MOSCCTL,
        _reserved3: [u8; 48usize],
        #[doc = "0xb0 - Run and Sleep Mode Configuration Register"]
        pub rsclkcfg: RSCLKCFG,
        _reserved4: [u8; 12usize],
        #[doc = "0xc0 - Memory Timing Parameter Register 0 for Main Flash and EEPROM"]
        pub memtim0: MEMTIM0,
        _reserved5: [u8; 116usize],
        #[doc = "0x138 - Alternate Clock Configuration"]
        pub altclkcfg: ALTCLKCFG,
        _reserved6: [u8; 8usize],
        #[doc = "0x144 - Deep Sleep Clock Configuration Register"]
        pub dsclkcfg: DSCLKCFG,
        #[doc = "0x148 - Divisor and Source Clock Configuration"]
        pub divsclk: DIVSCLK,
        #[doc = "0x14c - System Properties"]
        pub sysprop: SYSPROP,
        #[doc = "0x150 - Precision Internal Oscillator Calibration"]
        pub piosccal: PIOSCCAL,
        #[doc = "0x154 - Precision Internal Oscillator Statistics"]
        pub pioscstat: PIOSCSTAT,
        _reserved7: [u8; 8usize],
        #[doc = "0x160 - PLL Frequency 0"]
        pub pllfreq0: PLLFREQ0,
        #[doc = "0x164 - PLL Frequency 1"]
        pub pllfreq1: PLLFREQ1,
        #[doc = "0x168 - PLL Status"]
        pub pllstat: PLLSTAT,
        _reserved8: [u8; 28usize],
        #[doc = "0x188 - Sleep Power Configuration"]
        pub slppwrcfg: SLPPWRCFG,
        #[doc = "0x18c - Deep-Sleep Power Configuration"]
        pub dslppwrcfg: DSLPPWRCFG,
        _reserved9: [u8; 16usize],
        #[doc = "0x1a0 - Non-Volatile Memory Information"]
        pub nvmstat: NVMSTAT,
        _reserved10: [u8; 16usize],
        #[doc = "0x1b4 - LDO Sleep Power Control"]
        pub ldospctl: LDOSPCTL,
        _reserved11: [u8; 4usize],
        #[doc = "0x1bc - LDO Deep-Sleep Power Control"]
        pub ldodpctl: LDODPCTL,
        _reserved12: [u8; 24usize],
        #[doc = "0x1d8 - Reset Behavior Control Register"]
        pub resbehavctl: RESBEHAVCTL,
        _reserved13: [u8; 24usize],
        #[doc = "0x1f4 - Hardware System Service Request"]
        pub hssr: HSSR,
        _reserved14: [u8; 136usize],
        #[doc = "0x280 - USB Power Domain Status"]
        pub usbpds: USBPDS,
        #[doc = "0x284 - USB Memory Power Control"]
        pub usbmpc: USBMPC,
        #[doc = "0x288 - Ethernet MAC Power Domain Status"]
        pub emacpds: EMACPDS,
        #[doc = "0x28c - Ethernet MAC Memory Power Control"]
        pub emacmpc: EMACMPC,
        _reserved15: [u8; 112usize],
        #[doc = "0x300 - Watchdog Timer Peripheral Present"]
        pub ppwd: PPWD,
        #[doc = "0x304 - 16/32-Bit General-Purpose Timer Peripheral Present"]
        pub pptimer: PPTIMER,
        #[doc = "0x308 - General-Purpose Input/Output Peripheral Present"]
        pub ppgpio: PPGPIO,
        #[doc = "0x30c - Micro Direct Memory Access Peripheral Present"]
        pub ppdma: PPDMA,
        #[doc = "0x310 - EPI Peripheral Present"]
        pub ppepi: PPEPI,
        #[doc = "0x314 - Hibernation Peripheral Present"]
        pub pphib: PPHIB,
        #[doc = "0x318 - Universal Asynchronous Receiver/Transmitter Peripheral Present"]
        pub ppuart: PPUART,
        #[doc = "0x31c - Synchronous Serial Interface Peripheral Present"]
        pub ppssi: PPSSI,
        #[doc = "0x320 - Inter-Integrated Circuit Peripheral Present"]
        pub ppi2c: PPI2C,
        _reserved16: [u8; 4usize],
        #[doc = "0x328 - Universal Serial Bus Peripheral Present"]
        pub ppusb: PPUSB,
        _reserved17: [u8; 4usize],
        #[doc = "0x330 - Ethernet PHY Peripheral Present"]
        pub ppephy: PPEPHY,
        #[doc = "0x334 - Controller Area Network Peripheral Present"]
        pub ppcan: PPCAN,
        #[doc = "0x338 - Analog-to-Digital Converter Peripheral Present"]
        pub ppadc: PPADC,
        #[doc = "0x33c - Analog Comparator Peripheral Present"]
        pub ppacmp: PPACMP,
        #[doc = "0x340 - Pulse Width Modulator Peripheral Present"]
        pub pppwm: PPPWM,
        #[doc = "0x344 - Quadrature Encoder Interface Peripheral Present"]
        pub ppqei: PPQEI,
        #[doc = "0x348 - Low Pin Count Interface Peripheral Present"]
        pub pplpc: PPLPC,
        _reserved18: [u8; 4usize],
        #[doc = "0x350 - Platform Environment Control Interface Peripheral Present"]
        pub pppeci: PPPECI,
        #[doc = "0x354 - Fan Control Peripheral Present"]
        pub ppfan: PPFAN,
        #[doc = "0x358 - EEPROM Peripheral Present"]
        pub ppeeprom: PPEEPROM,
        #[doc = "0x35c - 32/64-Bit Wide General-Purpose Timer Peripheral Present"]
        pub ppwtimer: PPWTIMER,
        _reserved19: [u8; 16usize],
        #[doc = "0x370 - Remote Temperature Sensor Peripheral Present"]
        pub pprts: PPRTS,
        #[doc = "0x374 - CRC and Cryptographic Modules Peripheral Present"]
        pub ppccm: PPCCM,
        _reserved20: [u8; 24usize],
        #[doc = "0x390 - LCD Peripheral Present"]
        pub pplcd: PPLCD,
        _reserved21: [u8; 4usize],
        #[doc = "0x398 - 1-Wire Peripheral Present"]
        pub ppowire: PPOWIRE,
        #[doc = "0x39c - Ethernet MAC Peripheral Present"]
        pub ppemac: PPEMAC,
        _reserved22: [u8; 4usize],
        #[doc = "0x3a4 - Human Interface Master Peripheral Present"]
        pub pphim: PPHIM,
        _reserved23: [u8; 344usize],
        #[doc = "0x500 - Watchdog Timer Software Reset"]
        pub srwd: SRWD,
        #[doc = "0x504 - 16/32-Bit General-Purpose Timer Software Reset"]
        pub srtimer: SRTIMER,
        #[doc = "0x508 - General-Purpose Input/Output Software Reset"]
        pub srgpio: SRGPIO,
        #[doc = "0x50c - Micro Direct Memory Access Software Reset"]
        pub srdma: SRDMA,
        #[doc = "0x510 - EPI Software Reset"]
        pub srepi: SREPI,
        #[doc = "0x514 - Hibernation Software Reset"]
        pub srhib: SRHIB,
        #[doc = "0x518 - Universal Asynchronous Receiver/Transmitter Software Reset"]
        pub sruart: SRUART,
        #[doc = "0x51c - Synchronous Serial Interface Software Reset"]
        pub srssi: SRSSI,
        #[doc = "0x520 - Inter-Integrated Circuit Software Reset"]
        pub sri2c: SRI2C,
        _reserved24: [u8; 4usize],
        #[doc = "0x528 - Universal Serial Bus Software Reset"]
        pub srusb: SRUSB,
        _reserved25: [u8; 4usize],
        #[doc = "0x530 - Ethernet PHY Software Reset"]
        pub srephy: SREPHY,
        #[doc = "0x534 - Controller Area Network Software Reset"]
        pub srcan: SRCAN,
        #[doc = "0x538 - Analog-to-Digital Converter Software Reset"]
        pub sradc: SRADC,
        #[doc = "0x53c - Analog Comparator Software Reset"]
        pub sracmp: SRACMP,
        #[doc = "0x540 - Pulse Width Modulator Software Reset"]
        pub srpwm: SRPWM,
        #[doc = "0x544 - Quadrature Encoder Interface Software Reset"]
        pub srqei: SRQEI,
        _reserved26: [u8; 16usize],
        #[doc = "0x558 - EEPROM Software Reset"]
        pub sreeprom: SREEPROM,
        _reserved27: [u8; 24usize],
        #[doc = "0x574 - CRC and Cryptographic Modules Software Reset"]
        pub srccm: SRCCM,
        _reserved28: [u8; 36usize],
        #[doc = "0x59c - Ethernet MAC Software Reset"]
        pub sremac: SREMAC,
        _reserved29: [u8; 96usize],
        #[doc = "0x600 - Watchdog Timer Run Mode Clock Gating Control"]
        pub rcgcwd: RCGCWD,
        #[doc = "0x604 - 16/32-Bit General-Purpose Timer Run Mode Clock Gating Control"]
        pub rcgctimer: RCGCTIMER,
        #[doc = "0x608 - General-Purpose Input/Output Run Mode Clock Gating Control"]
        pub rcgcgpio: RCGCGPIO,
        #[doc = "0x60c - Micro Direct Memory Access Run Mode Clock Gating Control"]
        pub rcgcdma: RCGCDMA,
        #[doc = "0x610 - EPI Run Mode Clock Gating Control"]
        pub rcgcepi: RCGCEPI,
        #[doc = "0x614 - Hibernation Run Mode Clock Gating Control"]
        pub rcgchib: RCGCHIB,
        #[doc = "0x618 - Universal Asynchronous Receiver/Transmitter Run Mode Clock Gating Control"]
        pub rcgcuart: RCGCUART,
        #[doc = "0x61c - Synchronous Serial Interface Run Mode Clock Gating Control"]
        pub rcgcssi: RCGCSSI,
        #[doc = "0x620 - Inter-Integrated Circuit Run Mode Clock Gating Control"]
        pub rcgci2c: RCGCI2C,
        _reserved30: [u8; 4usize],
        #[doc = "0x628 - Universal Serial Bus Run Mode Clock Gating Control"]
        pub rcgcusb: RCGCUSB,
        _reserved31: [u8; 4usize],
        #[doc = "0x630 - Ethernet PHY Run Mode Clock Gating Control"]
        pub rcgcephy: RCGCEPHY,
        #[doc = "0x634 - Controller Area Network Run Mode Clock Gating Control"]
        pub rcgccan: RCGCCAN,
        #[doc = "0x638 - Analog-to-Digital Converter Run Mode Clock Gating Control"]
        pub rcgcadc: RCGCADC,
        #[doc = "0x63c - Analog Comparator Run Mode Clock Gating Control"]
        pub rcgcacmp: RCGCACMP,
        #[doc = "0x640 - Pulse Width Modulator Run Mode Clock Gating Control"]
        pub rcgcpwm: RCGCPWM,
        #[doc = "0x644 - Quadrature Encoder Interface Run Mode Clock Gating Control"]
        pub rcgcqei: RCGCQEI,
        _reserved32: [u8; 16usize],
        #[doc = "0x658 - EEPROM Run Mode Clock Gating Control"]
        pub rcgceeprom: RCGCEEPROM,
        _reserved33: [u8; 24usize],
        #[doc = "0x674 - CRC and Cryptographic Modules Run Mode Clock Gating Control"]
        pub rcgcccm: RCGCCCM,
        _reserved34: [u8; 36usize],
        #[doc = "0x69c - Ethernet MAC Run Mode Clock Gating Control"]
        pub rcgcemac: RCGCEMAC,
        _reserved35: [u8; 96usize],
        #[doc = "0x700 - Watchdog Timer Sleep Mode Clock Gating Control"]
        pub scgcwd: SCGCWD,
        #[doc = "0x704 - 16/32-Bit General-Purpose Timer Sleep Mode Clock Gating Control"]
        pub scgctimer: SCGCTIMER,
        #[doc = "0x708 - General-Purpose Input/Output Sleep Mode Clock Gating Control"]
        pub scgcgpio: SCGCGPIO,
        #[doc = "0x70c - Micro Direct Memory Access Sleep Mode Clock Gating Control"]
        pub scgcdma: SCGCDMA,
        #[doc = "0x710 - EPI Sleep Mode Clock Gating Control"]
        pub scgcepi: SCGCEPI,
        #[doc = "0x714 - Hibernation Sleep Mode Clock Gating Control"]
        pub scgchib: SCGCHIB,
        #[doc = "0x718 - Universal Asynchronous Receiver/Transmitter Sleep Mode Clock Gating Control"]
        pub scgcuart: SCGCUART,
        #[doc = "0x71c - Synchronous Serial Interface Sleep Mode Clock Gating Control"]
        pub scgcssi: SCGCSSI,
        #[doc = "0x720 - Inter-Integrated Circuit Sleep Mode Clock Gating Control"]
        pub scgci2c: SCGCI2C,
        _reserved36: [u8; 4usize],
        #[doc = "0x728 - Universal Serial Bus Sleep Mode Clock Gating Control"]
        pub scgcusb: SCGCUSB,
        _reserved37: [u8; 4usize],
        #[doc = "0x730 - Ethernet PHY Sleep Mode Clock Gating Control"]
        pub scgcephy: SCGCEPHY,
        #[doc = "0x734 - Controller Area Network Sleep Mode Clock Gating Control"]
        pub scgccan: SCGCCAN,
        #[doc = "0x738 - Analog-to-Digital Converter Sleep Mode Clock Gating Control"]
        pub scgcadc: SCGCADC,
        #[doc = "0x73c - Analog Comparator Sleep Mode Clock Gating Control"]
        pub scgcacmp: SCGCACMP,
        #[doc = "0x740 - Pulse Width Modulator Sleep Mode Clock Gating Control"]
        pub scgcpwm: SCGCPWM,
        #[doc = "0x744 - Quadrature Encoder Interface Sleep Mode Clock Gating Control"]
        pub scgcqei: SCGCQEI,
        _reserved38: [u8; 16usize],
        #[doc = "0x758 - EEPROM Sleep Mode Clock Gating Control"]
        pub scgceeprom: SCGCEEPROM,
        _reserved39: [u8; 24usize],
        #[doc = "0x774 - CRC and Cryptographic Modules Sleep Mode Clock Gating Control"]
        pub scgcccm: SCGCCCM,
        _reserved40: [u8; 36usize],
        #[doc = "0x79c - Ethernet MAC Sleep Mode Clock Gating Control"]
        pub scgcemac: SCGCEMAC,
        _reserved41: [u8; 96usize],
        #[doc = "0x800 - Watchdog Timer Deep-Sleep Mode Clock Gating Control"]
        pub dcgcwd: DCGCWD,
        #[doc = "0x804 - 16/32-Bit General-Purpose Timer Deep-Sleep Mode Clock Gating Control"]
        pub dcgctimer: DCGCTIMER,
        #[doc = "0x808 - General-Purpose Input/Output Deep-Sleep Mode Clock Gating Control"]
        pub dcgcgpio: DCGCGPIO,
        #[doc = "0x80c - Micro Direct Memory Access Deep-Sleep Mode Clock Gating Control"]
        pub dcgcdma: DCGCDMA,
        #[doc = "0x810 - EPI Deep-Sleep Mode Clock Gating Control"]
        pub dcgcepi: DCGCEPI,
        #[doc = "0x814 - Hibernation Deep-Sleep Mode Clock Gating Control"]
        pub dcgchib: DCGCHIB,
        #[doc = "0x818 - Universal Asynchronous Receiver/Transmitter Deep-Sleep Mode Clock Gating Control"]
        pub dcgcuart: DCGCUART,
        #[doc = "0x81c - Synchronous Serial Interface Deep-Sleep Mode Clock Gating Control"]
        pub dcgcssi: DCGCSSI,
        #[doc = "0x820 - Inter-Integrated Circuit Deep-Sleep Mode Clock Gating Control"]
        pub dcgci2c: DCGCI2C,
        _reserved42: [u8; 4usize],
        #[doc = "0x828 - Universal Serial Bus Deep-Sleep Mode Clock Gating Control"]
        pub dcgcusb: DCGCUSB,
        _reserved43: [u8; 4usize],
        #[doc = "0x830 - Ethernet PHY Deep-Sleep Mode Clock Gating Control"]
        pub dcgcephy: DCGCEPHY,
        #[doc = "0x834 - Controller Area Network Deep-Sleep Mode Clock Gating Control"]
        pub dcgccan: DCGCCAN,
        #[doc = "0x838 - Analog-to-Digital Converter Deep-Sleep Mode Clock Gating Control"]
        pub dcgcadc: DCGCADC,
        #[doc = "0x83c - Analog Comparator Deep-Sleep Mode Clock Gating Control"]
        pub dcgcacmp: DCGCACMP,
        #[doc = "0x840 - Pulse Width Modulator Deep-Sleep Mode Clock Gating Control"]
        pub dcgcpwm: DCGCPWM,
        #[doc = "0x844 - Quadrature Encoder Interface Deep-Sleep Mode Clock Gating Control"]
        pub dcgcqei: DCGCQEI,
        _reserved44: [u8; 16usize],
        #[doc = "0x858 - EEPROM Deep-Sleep Mode Clock Gating Control"]
        pub dcgceeprom: DCGCEEPROM,
        _reserved45: [u8; 24usize],
        #[doc = "0x874 - CRC and Cryptographic Modules Deep-Sleep Mode Clock Gating Control"]
        pub dcgcccm: DCGCCCM,
        _reserved46: [u8; 36usize],
        #[doc = "0x89c - Ethernet MAC Deep-Sleep Mode Clock Gating Control"]
        pub dcgcemac: DCGCEMAC,
        _reserved47: [u8; 96usize],
        #[doc = "0x900 - Watchdog Timer Power Control"]
        pub pcwd: PCWD,
        #[doc = "0x904 - 16/32-Bit General-Purpose Timer Power Control"]
        pub pctimer: PCTIMER,
        #[doc = "0x908 - General-Purpose Input/Output Power Control"]
        pub pcgpio: PCGPIO,
        #[doc = "0x90c - Micro Direct Memory Access Power Control"]
        pub pcdma: PCDMA,
        #[doc = "0x910 - External Peripheral Interface Power Control"]
        pub pcepi: PCEPI,
        #[doc = "0x914 - Hibernation Power Control"]
        pub pchib: PCHIB,
        #[doc = "0x918 - Universal Asynchronous Receiver/Transmitter Power Control"]
        pub pcuart: PCUART,
        #[doc = "0x91c - Synchronous Serial Interface Power Control"]
        pub pcssi: PCSSI,
        #[doc = "0x920 - Inter-Integrated Circuit Power Control"]
        pub pci2c: PCI2C,
        _reserved48: [u8; 4usize],
        #[doc = "0x928 - Universal Serial Bus Power Control"]
        pub pcusb: PCUSB,
        _reserved49: [u8; 4usize],
        #[doc = "0x930 - Ethernet PHY Power Control"]
        pub pcephy: PCEPHY,
        #[doc = "0x934 - Controller Area Network Power Control"]
        pub pccan: PCCAN,
        #[doc = "0x938 - Analog-to-Digital Converter Power Control"]
        pub pcadc: PCADC,
        #[doc = "0x93c - Analog Comparator Power Control"]
        pub pcacmp: PCACMP,
        #[doc = "0x940 - Pulse Width Modulator Power Control"]
        pub pcpwm: PCPWM,
        #[doc = "0x944 - Quadrature Encoder Interface Power Control"]
        pub pcqei: PCQEI,
        _reserved50: [u8; 16usize],
        #[doc = "0x958 - EEPROM Power Control"]
        pub pceeprom: PCEEPROM,
        _reserved51: [u8; 24usize],
        #[doc = "0x974 - CRC and Cryptographic Modules Power Control"]
        pub pcccm: PCCCM,
        _reserved52: [u8; 36usize],
        #[doc = "0x99c - Ethernet MAC Power Control"]
        pub pcemac: PCEMAC,
        _reserved53: [u8; 96usize],
        #[doc = "0xa00 - Watchdog Timer Peripheral Ready"]
        pub prwd: PRWD,
        #[doc = "0xa04 - 16/32-Bit General-Purpose Timer Peripheral Ready"]
        pub prtimer: PRTIMER,
        #[doc = "0xa08 - General-Purpose Input/Output Peripheral Ready"]
        pub prgpio: PRGPIO,
        #[doc = "0xa0c - Micro Direct Memory Access Peripheral Ready"]
        pub prdma: PRDMA,
        #[doc = "0xa10 - EPI Peripheral Ready"]
        pub prepi: PREPI,
        #[doc = "0xa14 - Hibernation Peripheral Ready"]
        pub prhib: PRHIB,
        #[doc = "0xa18 - Universal Asynchronous Receiver/Transmitter Peripheral Ready"]
        pub pruart: PRUART,
        #[doc = "0xa1c - Synchronous Serial Interface Peripheral Ready"]
        pub prssi: PRSSI,
        #[doc = "0xa20 - Inter-Integrated Circuit Peripheral Ready"]
        pub pri2c: PRI2C,
        _reserved54: [u8; 4usize],
        #[doc = "0xa28 - Universal Serial Bus Peripheral Ready"]
        pub prusb: PRUSB,
        _reserved55: [u8; 4usize],
        #[doc = "0xa30 - Ethernet PHY Peripheral Ready"]
        pub prephy: PREPHY,
        #[doc = "0xa34 - Controller Area Network Peripheral Ready"]
        pub prcan: PRCAN,
        #[doc = "0xa38 - Analog-to-Digital Converter Peripheral Ready"]
        pub pradc: PRADC,
        #[doc = "0xa3c - Analog Comparator Peripheral Ready"]
        pub pracmp: PRACMP,
        #[doc = "0xa40 - Pulse Width Modulator Peripheral Ready"]
        pub prpwm: PRPWM,
        #[doc = "0xa44 - Quadrature Encoder Interface Peripheral Ready"]
        pub prqei: PRQEI,
        _reserved56: [u8; 16usize],
        #[doc = "0xa58 - EEPROM Peripheral Ready"]
        pub preeprom: PREEPROM,
        _reserved57: [u8; 24usize],
        #[doc = "0xa74 - CRC and Cryptographic Modules Peripheral Ready"]
        pub prccm: PRCCM,
        _reserved58: [u8; 36usize],
        #[doc = "0xa9c - Ethernet MAC Peripheral Ready"]
        pub premac: PREMAC,
    }
    #[doc = "Device Identification 0"]
    pub struct DID0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Device Identification 0"]
    pub mod did0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::DID0 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `MIN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MINR {
            #[doc = "Initial device, or a major revision update"]
            _0,
            #[doc = "First metal layer change"]
            _1,
            #[doc = "Second metal layer change"]
            _2,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MINR::_0 => 0,
                    MINR::_1 => 0x01,
                    MINR::_2 => 0x02,
                    MINR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MINR {
                match value {
                    0 => MINR::_0,
                    1 => MINR::_1,
                    2 => MINR::_2,
                    i => MINR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == MINR::_0
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == MINR::_1
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == MINR::_2
            }
        }
        #[doc = "Possible values of the field `MAJ`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MAJR {
            #[doc = "Revision A (initial device)"]
            REVA,
            #[doc = "Revision B (first base layer revision)"]
            REVB,
            #[doc = "Revision C (second base layer revision)"]
            REVC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MAJR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MAJR::REVA => 0,
                    MAJR::REVB => 0x01,
                    MAJR::REVC => 0x02,
                    MAJR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MAJR {
                match value {
                    0 => MAJR::REVA,
                    1 => MAJR::REVB,
                    2 => MAJR::REVC,
                    i => MAJR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `REVA`"]
            #[inline]
            pub fn is_reva(&self) -> bool {
                *self == MAJR::REVA
            }
            #[doc = "Checks if the value of the field is `REVB`"]
            #[inline]
            pub fn is_revb(&self) -> bool {
                *self == MAJR::REVB
            }
            #[doc = "Checks if the value of the field is `REVC`"]
            #[inline]
            pub fn is_revc(&self) -> bool {
                *self == MAJR::REVC
            }
        }
        #[doc = "Possible values of the field `CLASS`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CLASSR {
            #[doc = "Tiva(TM) TM4C129-class microcontrollers"]
            TM4C129,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CLASSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CLASSR::TM4C129 => 0x0a,
                    CLASSR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CLASSR {
                match value {
                    10 => CLASSR::TM4C129,
                    i => CLASSR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `TM4C129`"]
            #[inline]
            pub fn is_tm4c129(&self) -> bool {
                *self == CLASSR::TM4C129
            }
        }
        #[doc = "Possible values of the field `VER`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VERR {
            #[doc = "Second version of the DID0 register format."]
            _1,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl VERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VERR::_1 => 0x01,
                    VERR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VERR {
                match value {
                    1 => VERR::_1,
                    i => VERR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == VERR::_1
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Minor Revision"]
            #[inline]
            pub fn min(&self) -> MINR {
                MINR::_from({
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:15 - Major Revision"]
            #[inline]
            pub fn maj(&self) -> MAJR {
                MAJR::_from({
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:23 - Device Class"]
            #[inline]
            pub fn class(&self) -> CLASSR {
                CLASSR::_from({
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 28:30 - DID0 Version"]
            #[inline]
            pub fn ver(&self) -> VERR {
                VERR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
    }
    #[doc = "Device Identification 1"]
    pub struct DID1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Device Identification 1"]
    pub mod did1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::DID1 {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `QUAL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum QUALR {
            #[doc = "Engineering Sample (unqualified)"]
            ES,
            #[doc = "Pilot Production (unqualified)"]
            PP,
            #[doc = "Fully Qualified"]
            FQ,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl QUALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    QUALR::ES => 0,
                    QUALR::PP => 0x01,
                    QUALR::FQ => 0x02,
                    QUALR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> QUALR {
                match value {
                    0 => QUALR::ES,
                    1 => QUALR::PP,
                    2 => QUALR::FQ,
                    i => QUALR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `ES`"]
            #[inline]
            pub fn is_es(&self) -> bool {
                *self == QUALR::ES
            }
            #[doc = "Checks if the value of the field is `PP`"]
            #[inline]
            pub fn is_pp(&self) -> bool {
                *self == QUALR::PP
            }
            #[doc = "Checks if the value of the field is `FQ`"]
            #[inline]
            pub fn is_fq(&self) -> bool {
                *self == QUALR::FQ
            }
        }
        #[doc = r" Value of the field"]
        pub struct ROHSR {
            bits: bool,
        }
        impl ROHSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `PKG`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PKGR {
            #[doc = "QFP package"]
            QFP,
            #[doc = "BGA package"]
            BGA,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PKGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PKGR::QFP => 0x01,
                    PKGR::BGA => 0x02,
                    PKGR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PKGR {
                match value {
                    1 => PKGR::QFP,
                    2 => PKGR::BGA,
                    i => PKGR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `QFP`"]
            #[inline]
            pub fn is_qfp(&self) -> bool {
                *self == PKGR::QFP
            }
            #[doc = "Checks if the value of the field is `BGA`"]
            #[inline]
            pub fn is_bga(&self) -> bool {
                *self == PKGR::BGA
            }
        }
        #[doc = "Possible values of the field `TEMP`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TEMPR {
            #[doc = "Commercial temperature range"]
            C,
            #[doc = "Industrial temperature range"]
            I,
            #[doc = "Extended temperature range"]
            E,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TEMPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TEMPR::C => 0,
                    TEMPR::I => 0x01,
                    TEMPR::E => 0x02,
                    TEMPR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TEMPR {
                match value {
                    0 => TEMPR::C,
                    1 => TEMPR::I,
                    2 => TEMPR::E,
                    i => TEMPR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `C`"]
            #[inline]
            pub fn is_c(&self) -> bool {
                *self == TEMPR::C
            }
            #[doc = "Checks if the value of the field is `I`"]
            #[inline]
            pub fn is_i(&self) -> bool {
                *self == TEMPR::I
            }
            #[doc = "Checks if the value of the field is `E`"]
            #[inline]
            pub fn is_e(&self) -> bool {
                *self == TEMPR::E
            }
        }
        #[doc = "Possible values of the field `PINCNT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PINCNTR {
            #[doc = "100-pin LQFP package"]
            _100,
            #[doc = "64-pin LQFP package"]
            _64,
            #[doc = "144-pin LQFP package"]
            _144,
            #[doc = "157-pin BGA package"]
            _157,
            #[doc = "128-pin TQFP package"]
            _128,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PINCNTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PINCNTR::_100 => 0x02,
                    PINCNTR::_64 => 0x03,
                    PINCNTR::_144 => 0x04,
                    PINCNTR::_157 => 0x05,
                    PINCNTR::_128 => 0x06,
                    PINCNTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PINCNTR {
                match value {
                    2 => PINCNTR::_100,
                    3 => PINCNTR::_64,
                    4 => PINCNTR::_144,
                    5 => PINCNTR::_157,
                    6 => PINCNTR::_128,
                    i => PINCNTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_100`"]
            #[inline]
            pub fn is_100(&self) -> bool {
                *self == PINCNTR::_100
            }
            #[doc = "Checks if the value of the field is `_64`"]
            #[inline]
            pub fn is_64(&self) -> bool {
                *self == PINCNTR::_64
            }
            #[doc = "Checks if the value of the field is `_144`"]
            #[inline]
            pub fn is_144(&self) -> bool {
                *self == PINCNTR::_144
            }
            #[doc = "Checks if the value of the field is `_157`"]
            #[inline]
            pub fn is_157(&self) -> bool {
                *self == PINCNTR::_157
            }
            #[doc = "Checks if the value of the field is `_128`"]
            #[inline]
            pub fn is_128(&self) -> bool {
                *self == PINCNTR::_128
            }
        }
        #[doc = r" Value of the field"]
        pub struct PRTNOR {
            bits: u8,
        }
        impl PRTNOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FAMR {
            bits: u8,
        }
        impl FAMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct VERR {
            bits: u8,
        }
        impl VERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Qualification Status"]
            #[inline]
            pub fn qual(&self) -> QUALR {
                QUALR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 2 - RoHS-Compliance"]
            #[inline]
            pub fn rohs(&self) -> ROHSR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ROHSR { bits }
            }
            #[doc = "Bits 3:4 - Package Type"]
            #[inline]
            pub fn pkg(&self) -> PKGR {
                PKGR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 5:7 - Temperature Range"]
            #[inline]
            pub fn temp(&self) -> TEMPR {
                TEMPR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 13:15 - Package Pin Count"]
            #[inline]
            pub fn pincnt(&self) -> PINCNTR {
                PINCNTR::_from({
                    const MASK: u8 = 0x07;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:23 - Part Number"]
            #[inline]
            pub fn prtno(&self) -> PRTNOR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                PRTNOR { bits }
            }
            #[doc = "Bits 24:27 - Family"]
            #[inline]
            pub fn fam(&self) -> FAMR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FAMR { bits }
            }
            #[doc = "Bits 28:31 - DID1 Version"]
            #[inline]
            pub fn ver(&self) -> VERR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                VERR { bits }
            }
        }
    }
    #[doc = "Power-Temp Brown Out Control"]
    pub struct PTBOCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Power-Temp Brown Out Control"]
    pub mod ptboctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PTBOCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `VDD_UBOR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VDD_UBORR {
            #[doc = "No Action"]
            NONE,
            #[doc = "System control interrupt"]
            SYSINT,
            #[doc = "NMI"]
            NMI,
            #[doc = "Reset"]
            RST,
        }
        impl VDD_UBORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VDD_UBORR::NONE => 0,
                    VDD_UBORR::SYSINT => 0x01,
                    VDD_UBORR::NMI => 0x02,
                    VDD_UBORR::RST => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VDD_UBORR {
                match value {
                    0 => VDD_UBORR::NONE,
                    1 => VDD_UBORR::SYSINT,
                    2 => VDD_UBORR::NMI,
                    3 => VDD_UBORR::RST,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == VDD_UBORR::NONE
            }
            #[doc = "Checks if the value of the field is `SYSINT`"]
            #[inline]
            pub fn is_sysint(&self) -> bool {
                *self == VDD_UBORR::SYSINT
            }
            #[doc = "Checks if the value of the field is `NMI`"]
            #[inline]
            pub fn is_nmi(&self) -> bool {
                *self == VDD_UBORR::NMI
            }
            #[doc = "Checks if the value of the field is `RST`"]
            #[inline]
            pub fn is_rst(&self) -> bool {
                *self == VDD_UBORR::RST
            }
        }
        #[doc = "Possible values of the field `VDDA_UBOR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VDDA_UBORR {
            #[doc = "No Action"]
            NONE,
            #[doc = "System control interrupt"]
            SYSINT,
            #[doc = "NMI"]
            NMI,
            #[doc = "Reset"]
            RST,
        }
        impl VDDA_UBORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VDDA_UBORR::NONE => 0,
                    VDDA_UBORR::SYSINT => 0x01,
                    VDDA_UBORR::NMI => 0x02,
                    VDDA_UBORR::RST => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VDDA_UBORR {
                match value {
                    0 => VDDA_UBORR::NONE,
                    1 => VDDA_UBORR::SYSINT,
                    2 => VDDA_UBORR::NMI,
                    3 => VDDA_UBORR::RST,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `NONE`"]
            #[inline]
            pub fn is_none(&self) -> bool {
                *self == VDDA_UBORR::NONE
            }
            #[doc = "Checks if the value of the field is `SYSINT`"]
            #[inline]
            pub fn is_sysint(&self) -> bool {
                *self == VDDA_UBORR::SYSINT
            }
            #[doc = "Checks if the value of the field is `NMI`"]
            #[inline]
            pub fn is_nmi(&self) -> bool {
                *self == VDDA_UBORR::NMI
            }
            #[doc = "Checks if the value of the field is `RST`"]
            #[inline]
            pub fn is_rst(&self) -> bool {
                *self == VDDA_UBORR::RST
            }
        }
        #[doc = "Values that can be written to the field `VDD_UBOR`"]
        pub enum VDD_UBORW {
            #[doc = "No Action"]
            NONE,
            #[doc = "System control interrupt"]
            SYSINT,
            #[doc = "NMI"]
            NMI,
            #[doc = "Reset"]
            RST,
        }
        impl VDD_UBORW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VDD_UBORW::NONE => 0,
                    VDD_UBORW::SYSINT => 1,
                    VDD_UBORW::NMI => 2,
                    VDD_UBORW::RST => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDD_UBORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDD_UBORW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VDD_UBORW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No Action"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(VDD_UBORW::NONE)
            }
            #[doc = "System control interrupt"]
            #[inline]
            pub fn sysint(self) -> &'a mut W {
                self.variant(VDD_UBORW::SYSINT)
            }
            #[doc = "NMI"]
            #[inline]
            pub fn nmi(self) -> &'a mut W {
                self.variant(VDD_UBORW::NMI)
            }
            #[doc = "Reset"]
            #[inline]
            pub fn rst(self) -> &'a mut W {
                self.variant(VDD_UBORW::RST)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `VDDA_UBOR`"]
        pub enum VDDA_UBORW {
            #[doc = "No Action"]
            NONE,
            #[doc = "System control interrupt"]
            SYSINT,
            #[doc = "NMI"]
            NMI,
            #[doc = "Reset"]
            RST,
        }
        impl VDDA_UBORW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VDDA_UBORW::NONE => 0,
                    VDDA_UBORW::SYSINT => 1,
                    VDDA_UBORW::NMI => 2,
                    VDDA_UBORW::RST => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDDA_UBORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDDA_UBORW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VDDA_UBORW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "No Action"]
            #[inline]
            pub fn none(self) -> &'a mut W {
                self.variant(VDDA_UBORW::NONE)
            }
            #[doc = "System control interrupt"]
            #[inline]
            pub fn sysint(self) -> &'a mut W {
                self.variant(VDDA_UBORW::SYSINT)
            }
            #[doc = "NMI"]
            #[inline]
            pub fn nmi(self) -> &'a mut W {
                self.variant(VDDA_UBORW::NMI)
            }
            #[doc = "Reset"]
            #[inline]
            pub fn rst(self) -> &'a mut W {
                self.variant(VDDA_UBORW::RST)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - VDD (VDDS) under BOR Event Action"]
            #[inline]
            pub fn vdd_ubor(&self) -> VDD_UBORR {
                VDD_UBORR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 8:9 - VDDA under BOR Event Action"]
            #[inline]
            pub fn vdda_ubor(&self) -> VDDA_UBORR {
                VDDA_UBORR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - VDD (VDDS) under BOR Event Action"]
            #[inline]
            pub fn vdd_ubor(&mut self) -> _VDD_UBORW {
                _VDD_UBORW { w: self }
            }
            #[doc = "Bits 8:9 - VDDA under BOR Event Action"]
            #[inline]
            pub fn vdda_ubor(&mut self) -> _VDDA_UBORW {
                _VDDA_UBORW { w: self }
            }
        }
    }
    #[doc = "Raw Interrupt Status"]
    pub struct RIS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Raw Interrupt Status"]
    pub mod ris {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::RIS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct BORRISR {
            bits: bool,
        }
        impl BORRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOFRISR {
            bits: bool,
        }
        impl MOFRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PLLLRISR {
            bits: bool,
        }
        impl PLLLRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCPUPRISR {
            bits: bool,
        }
        impl MOSCPUPRISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Brown-Out Reset Raw Interrupt Status"]
            #[inline]
            pub fn borris(&self) -> BORRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BORRISR { bits }
            }
            #[doc = "Bit 3 - Main Oscillator Failure Raw Interrupt Status"]
            #[inline]
            pub fn mofris(&self) -> MOFRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOFRISR { bits }
            }
            #[doc = "Bit 6 - PLL Lock Raw Interrupt Status"]
            #[inline]
            pub fn plllris(&self) -> PLLLRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PLLLRISR { bits }
            }
            #[doc = "Bit 8 - MOSC Power Up Raw Interrupt Status"]
            #[inline]
            pub fn moscpupris(&self) -> MOSCPUPRISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCPUPRISR { bits }
            }
        }
    }
    #[doc = "Interrupt Mask Control"]
    pub struct IMC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Interrupt Mask Control"]
    pub mod imc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::IMC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BORIMR {
            bits: bool,
        }
        impl BORIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOFIMR {
            bits: bool,
        }
        impl MOFIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PLLLIMR {
            bits: bool,
        }
        impl PLLLIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCPUPIMR {
            bits: bool,
        }
        impl MOSCPUPIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _BORIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BORIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOFIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOFIMW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PLLLIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PLLLIMW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCPUPIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCPUPIMW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - Brown-Out Reset Interrupt Mask"]
            #[inline]
            pub fn borim(&self) -> BORIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BORIMR { bits }
            }
            #[doc = "Bit 3 - Main Oscillator Failure Interrupt Mask"]
            #[inline]
            pub fn mofim(&self) -> MOFIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOFIMR { bits }
            }
            #[doc = "Bit 6 - PLL Lock Interrupt Mask"]
            #[inline]
            pub fn plllim(&self) -> PLLLIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PLLLIMR { bits }
            }
            #[doc = "Bit 8 - MOSC Power Up Interrupt Mask"]
            #[inline]
            pub fn moscpupim(&self) -> MOSCPUPIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCPUPIMR { bits }
            }
        }
        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 = "Bit 1 - Brown-Out Reset Interrupt Mask"]
            #[inline]
            pub fn borim(&mut self) -> _BORIMW {
                _BORIMW { w: self }
            }
            #[doc = "Bit 3 - Main Oscillator Failure Interrupt Mask"]
            #[inline]
            pub fn mofim(&mut self) -> _MOFIMW {
                _MOFIMW { w: self }
            }
            #[doc = "Bit 6 - PLL Lock Interrupt Mask"]
            #[inline]
            pub fn plllim(&mut self) -> _PLLLIMW {
                _PLLLIMW { w: self }
            }
            #[doc = "Bit 8 - MOSC Power Up Interrupt Mask"]
            #[inline]
            pub fn moscpupim(&mut self) -> _MOSCPUPIMW {
                _MOSCPUPIMW { w: self }
            }
        }
    }
    #[doc = "Masked Interrupt Status and Clear"]
    pub struct MISC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Masked Interrupt Status and Clear"]
    pub mod misc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MISC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct BORMISR {
            bits: bool,
        }
        impl BORMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOFMISR {
            bits: bool,
        }
        impl MOFMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PLLLMISR {
            bits: bool,
        }
        impl PLLLMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCPUPMISR {
            bits: bool,
        }
        impl MOSCPUPMISR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _BORMISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BORMISW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOFMISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOFMISW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PLLLMISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PLLLMISW<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCPUPMISW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCPUPMISW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 1 - BOR Masked Interrupt Status"]
            #[inline]
            pub fn bormis(&self) -> BORMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BORMISR { bits }
            }
            #[doc = "Bit 3 - Main Oscillator Failure Masked Interrupt Status"]
            #[inline]
            pub fn mofmis(&self) -> MOFMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOFMISR { bits }
            }
            #[doc = "Bit 6 - PLL Lock Masked Interrupt Status"]
            #[inline]
            pub fn plllmis(&self) -> PLLLMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PLLLMISR { bits }
            }
            #[doc = "Bit 8 - MOSC Power Up Masked Interrupt Status"]
            #[inline]
            pub fn moscpupmis(&self) -> MOSCPUPMISR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCPUPMISR { bits }
            }
        }
        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 = "Bit 1 - BOR Masked Interrupt Status"]
            #[inline]
            pub fn bormis(&mut self) -> _BORMISW {
                _BORMISW { w: self }
            }
            #[doc = "Bit 3 - Main Oscillator Failure Masked Interrupt Status"]
            #[inline]
            pub fn mofmis(&mut self) -> _MOFMISW {
                _MOFMISW { w: self }
            }
            #[doc = "Bit 6 - PLL Lock Masked Interrupt Status"]
            #[inline]
            pub fn plllmis(&mut self) -> _PLLLMISW {
                _PLLLMISW { w: self }
            }
            #[doc = "Bit 8 - MOSC Power Up Masked Interrupt Status"]
            #[inline]
            pub fn moscpupmis(&mut self) -> _MOSCPUPMISW {
                _MOSCPUPMISW { w: self }
            }
        }
    }
    #[doc = "Reset Cause"]
    pub struct RESC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Reset Cause"]
    pub mod resc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RESC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTR {
            bits: bool,
        }
        impl EXTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PORR {
            bits: bool,
        }
        impl PORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct BORR {
            bits: bool,
        }
        impl BORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDT0R {
            bits: bool,
        }
        impl WDT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SWR {
            bits: bool,
        }
        impl SWR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDT1R {
            bits: bool,
        }
        impl WDT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct HSSRR {
            bits: bool,
        }
        impl HSSRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCFAILR {
            bits: bool,
        }
        impl MOSCFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _PORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PORW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BORW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDT0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SWW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SWW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDT1W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _HSSRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _HSSRW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCFAILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCFAILW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - External Reset"]
            #[inline]
            pub fn ext(&self) -> EXTR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTR { bits }
            }
            #[doc = "Bit 1 - Power-On Reset"]
            #[inline]
            pub fn por(&self) -> PORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PORR { bits }
            }
            #[doc = "Bit 2 - Brown-Out Reset"]
            #[inline]
            pub fn bor(&self) -> BORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BORR { bits }
            }
            #[doc = "Bit 3 - Watchdog Timer 0 Reset"]
            #[inline]
            pub fn wdt0(&self) -> WDT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDT0R { bits }
            }
            #[doc = "Bit 4 - Software Reset"]
            #[inline]
            pub fn sw(&self) -> SWR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SWR { bits }
            }
            #[doc = "Bit 5 - Watchdog Timer 1 Reset"]
            #[inline]
            pub fn wdt1(&self) -> WDT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDT1R { bits }
            }
            #[doc = "Bit 12 - HSSR Reset"]
            #[inline]
            pub fn hssr(&self) -> HSSRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                HSSRR { bits }
            }
            #[doc = "Bit 16 - MOSC Failure Reset"]
            #[inline]
            pub fn moscfail(&self) -> MOSCFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCFAILR { bits }
            }
        }
        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 = "Bit 0 - External Reset"]
            #[inline]
            pub fn ext(&mut self) -> _EXTW {
                _EXTW { w: self }
            }
            #[doc = "Bit 1 - Power-On Reset"]
            #[inline]
            pub fn por(&mut self) -> _PORW {
                _PORW { w: self }
            }
            #[doc = "Bit 2 - Brown-Out Reset"]
            #[inline]
            pub fn bor(&mut self) -> _BORW {
                _BORW { w: self }
            }
            #[doc = "Bit 3 - Watchdog Timer 0 Reset"]
            #[inline]
            pub fn wdt0(&mut self) -> _WDT0W {
                _WDT0W { w: self }
            }
            #[doc = "Bit 4 - Software Reset"]
            #[inline]
            pub fn sw(&mut self) -> _SWW {
                _SWW { w: self }
            }
            #[doc = "Bit 5 - Watchdog Timer 1 Reset"]
            #[inline]
            pub fn wdt1(&mut self) -> _WDT1W {
                _WDT1W { w: self }
            }
            #[doc = "Bit 12 - HSSR Reset"]
            #[inline]
            pub fn hssr(&mut self) -> _HSSRW {
                _HSSRW { w: self }
            }
            #[doc = "Bit 16 - MOSC Failure Reset"]
            #[inline]
            pub fn moscfail(&mut self) -> _MOSCFAILW {
                _MOSCFAILW { w: self }
            }
        }
    }
    #[doc = "Power-Temperature Cause"]
    pub struct PWRTC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Power-Temperature Cause"]
    pub mod pwrtc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PWRTC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDD_UBORR {
            bits: bool,
        }
        impl VDD_UBORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct VDDA_UBORR {
            bits: bool,
        }
        impl VDDA_UBORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDD_UBORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDD_UBORW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _VDDA_UBORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VDDA_UBORW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - VDD Under BOR Status"]
            #[inline]
            pub fn vdd_ubor(&self) -> VDD_UBORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDD_UBORR { bits }
            }
            #[doc = "Bit 4 - VDDA Under BOR Status"]
            #[inline]
            pub fn vdda_ubor(&self) -> VDDA_UBORR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VDDA_UBORR { bits }
            }
        }
        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 = "Bit 0 - VDD Under BOR Status"]
            #[inline]
            pub fn vdd_ubor(&mut self) -> _VDD_UBORW {
                _VDD_UBORW { w: self }
            }
            #[doc = "Bit 4 - VDDA Under BOR Status"]
            #[inline]
            pub fn vdda_ubor(&mut self) -> _VDDA_UBORW {
                _VDDA_UBORW { w: self }
            }
        }
    }
    #[doc = "NMI Cause Register"]
    pub struct NMIC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "NMI Cause Register"]
    pub mod nmic {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::NMIC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct EXTERNALR {
            bits: bool,
        }
        impl EXTERNALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct POWERR {
            bits: bool,
        }
        impl POWERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDT0R {
            bits: bool,
        }
        impl WDT0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct WDT1R {
            bits: bool,
        }
        impl WDT1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct TAMPERR {
            bits: bool,
        }
        impl TAMPERR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCFAILR {
            bits: bool,
        }
        impl MOSCFAILR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTERNALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTERNALW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _POWERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _POWERW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDT0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDT0W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDT1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDT1W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TAMPERW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TAMPERW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCFAILW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCFAILW<'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 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - External Pin NMI"]
            #[inline]
            pub fn external(&self) -> EXTERNALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EXTERNALR { bits }
            }
            #[doc = "Bit 2 - Power/Brown Out Event NMI"]
            #[inline]
            pub fn power(&self) -> POWERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                POWERR { bits }
            }
            #[doc = "Bit 3 - Watch Dog Timer (WDT) 0 NMI"]
            #[inline]
            pub fn wdt0(&self) -> WDT0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDT0R { bits }
            }
            #[doc = "Bit 5 - Watch Dog Timer (WDT) 1 NMI"]
            #[inline]
            pub fn wdt1(&self) -> WDT1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                WDT1R { bits }
            }
            #[doc = "Bit 9 - Tamper Event NMI"]
            #[inline]
            pub fn tamper(&self) -> TAMPERR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TAMPERR { bits }
            }
            #[doc = "Bit 16 - MOSC Failure NMI"]
            #[inline]
            pub fn moscfail(&self) -> MOSCFAILR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCFAILR { bits }
            }
        }
        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 = "Bit 0 - External Pin NMI"]
            #[inline]
            pub fn external(&mut self) -> _EXTERNALW {
                _EXTERNALW { w: self }
            }
            #[doc = "Bit 2 - Power/Brown Out Event NMI"]
            #[inline]
            pub fn power(&mut self) -> _POWERW {
                _POWERW { w: self }
            }
            #[doc = "Bit 3 - Watch Dog Timer (WDT) 0 NMI"]
            #[inline]
            pub fn wdt0(&mut self) -> _WDT0W {
                _WDT0W { w: self }
            }
            #[doc = "Bit 5 - Watch Dog Timer (WDT) 1 NMI"]
            #[inline]
            pub fn wdt1(&mut self) -> _WDT1W {
                _WDT1W { w: self }
            }
            #[doc = "Bit 9 - Tamper Event NMI"]
            #[inline]
            pub fn tamper(&mut self) -> _TAMPERW {
                _TAMPERW { w: self }
            }
            #[doc = "Bit 16 - MOSC Failure NMI"]
            #[inline]
            pub fn moscfail(&mut self) -> _MOSCFAILW {
                _MOSCFAILW { w: self }
            }
        }
    }
    #[doc = "Main Oscillator Control"]
    pub struct MOSCCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Main Oscillator Control"]
    pub mod moscctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MOSCCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CVALR {
            bits: bool,
        }
        impl CVALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCIMR {
            bits: bool,
        }
        impl MOSCIMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NOXTALR {
            bits: bool,
        }
        impl NOXTALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PWRDNR {
            bits: bool,
        }
        impl PWRDNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSCRNGR {
            bits: bool,
        }
        impl OSCRNGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _CVALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CVALW<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCIMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCIMW<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NOXTALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NOXTALW<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWRDNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWRDNW<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSCRNGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSCRNGW<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Clock Validation for MOSC"]
            #[inline]
            pub fn cval(&self) -> CVALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CVALR { bits }
            }
            #[doc = "Bit 1 - MOSC Failure Action"]
            #[inline]
            pub fn moscim(&self) -> MOSCIMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCIMR { bits }
            }
            #[doc = "Bit 2 - No Crystal Connected"]
            #[inline]
            pub fn noxtal(&self) -> NOXTALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NOXTALR { bits }
            }
            #[doc = "Bit 3 - Power Down"]
            #[inline]
            pub fn pwrdn(&self) -> PWRDNR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PWRDNR { bits }
            }
            #[doc = "Bit 4 - Oscillator Range"]
            #[inline]
            pub fn oscrng(&self) -> OSCRNGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OSCRNGR { bits }
            }
        }
        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 = "Bit 0 - Clock Validation for MOSC"]
            #[inline]
            pub fn cval(&mut self) -> _CVALW {
                _CVALW { w: self }
            }
            #[doc = "Bit 1 - MOSC Failure Action"]
            #[inline]
            pub fn moscim(&mut self) -> _MOSCIMW {
                _MOSCIMW { w: self }
            }
            #[doc = "Bit 2 - No Crystal Connected"]
            #[inline]
            pub fn noxtal(&mut self) -> _NOXTALW {
                _NOXTALW { w: self }
            }
            #[doc = "Bit 3 - Power Down"]
            #[inline]
            pub fn pwrdn(&mut self) -> _PWRDNW {
                _PWRDNW { w: self }
            }
            #[doc = "Bit 4 - Oscillator Range"]
            #[inline]
            pub fn oscrng(&mut self) -> _OSCRNGW {
                _OSCRNGW { w: self }
            }
        }
    }
    #[doc = "Run and Sleep Mode Configuration Register"]
    pub struct RSCLKCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Run and Sleep Mode Configuration Register"]
    pub mod rsclkcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RSCLKCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct PSYSDIVR {
            bits: u16,
        }
        impl PSYSDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct OSYSDIVR {
            bits: u16,
        }
        impl OSYSDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `OSCSRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum OSCSRCR {
            #[doc = "PIOSC is oscillator source"]
            PIOSC,
            #[doc = "LFIOSC is oscillator source"]
            LFIOSC,
            #[doc = "MOSC is oscillator source"]
            MOSC,
            #[doc = "Hibernation Module RTC Oscillator (RTCOSC)"]
            RTC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl OSCSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    OSCSRCR::PIOSC => 0,
                    OSCSRCR::LFIOSC => 0x02,
                    OSCSRCR::MOSC => 0x03,
                    OSCSRCR::RTC => 0x04,
                    OSCSRCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> OSCSRCR {
                match value {
                    0 => OSCSRCR::PIOSC,
                    2 => OSCSRCR::LFIOSC,
                    3 => OSCSRCR::MOSC,
                    4 => OSCSRCR::RTC,
                    i => OSCSRCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == OSCSRCR::PIOSC
            }
            #[doc = "Checks if the value of the field is `LFIOSC`"]
            #[inline]
            pub fn is_lfiosc(&self) -> bool {
                *self == OSCSRCR::LFIOSC
            }
            #[doc = "Checks if the value of the field is `MOSC`"]
            #[inline]
            pub fn is_mosc(&self) -> bool {
                *self == OSCSRCR::MOSC
            }
            #[doc = "Checks if the value of the field is `RTC`"]
            #[inline]
            pub fn is_rtc(&self) -> bool {
                *self == OSCSRCR::RTC
            }
        }
        #[doc = "Possible values of the field `PLLSRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PLLSRCR {
            #[doc = "PIOSC is PLL input clock source"]
            PIOSC,
            #[doc = "MOSC is the PLL input clock source"]
            MOSC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PLLSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PLLSRCR::PIOSC => 0,
                    PLLSRCR::MOSC => 0x03,
                    PLLSRCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PLLSRCR {
                match value {
                    0 => PLLSRCR::PIOSC,
                    3 => PLLSRCR::MOSC,
                    i => PLLSRCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == PLLSRCR::PIOSC
            }
            #[doc = "Checks if the value of the field is `MOSC`"]
            #[inline]
            pub fn is_mosc(&self) -> bool {
                *self == PLLSRCR::MOSC
            }
        }
        #[doc = r" Value of the field"]
        pub struct USEPLLR {
            bits: bool,
        }
        impl USEPLLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct ACGR {
            bits: bool,
        }
        impl ACGR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct NEWFREQR {
            bits: bool,
        }
        impl NEWFREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct MEMTIMUR {
            bits: bool,
        }
        impl MEMTIMUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _PSYSDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PSYSDIVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x03ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSYSDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSYSDIVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x03ff;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `OSCSRC`"]
        pub enum OSCSRCW {
            #[doc = "PIOSC is oscillator source"]
            PIOSC,
            #[doc = "LFIOSC is oscillator source"]
            LFIOSC,
            #[doc = "MOSC is oscillator source"]
            MOSC,
            #[doc = "Hibernation Module RTC Oscillator (RTCOSC)"]
            RTC,
        }
        impl OSCSRCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    OSCSRCW::PIOSC => 0,
                    OSCSRCW::LFIOSC => 2,
                    OSCSRCW::MOSC => 3,
                    OSCSRCW::RTC => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _OSCSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OSCSRCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: OSCSRCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "PIOSC is oscillator source"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(OSCSRCW::PIOSC)
            }
            #[doc = "LFIOSC is oscillator source"]
            #[inline]
            pub fn lfiosc(self) -> &'a mut W {
                self.variant(OSCSRCW::LFIOSC)
            }
            #[doc = "MOSC is oscillator source"]
            #[inline]
            pub fn mosc(self) -> &'a mut W {
                self.variant(OSCSRCW::MOSC)
            }
            #[doc = "Hibernation Module RTC Oscillator (RTCOSC)"]
            #[inline]
            pub fn rtc(self) -> &'a mut W {
                self.variant(OSCSRCW::RTC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `PLLSRC`"]
        pub enum PLLSRCW {
            #[doc = "PIOSC is PLL input clock source"]
            PIOSC,
            #[doc = "MOSC is the PLL input clock source"]
            MOSC,
        }
        impl PLLSRCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PLLSRCW::PIOSC => 0,
                    PLLSRCW::MOSC => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PLLSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PLLSRCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PLLSRCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "PIOSC is PLL input clock source"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(PLLSRCW::PIOSC)
            }
            #[doc = "MOSC is the PLL input clock source"]
            #[inline]
            pub fn mosc(self) -> &'a mut W {
                self.variant(PLLSRCW::MOSC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _USEPLLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _USEPLLW<'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 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ACGW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ACGW<'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 = 29;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _NEWFREQW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NEWFREQW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MEMTIMUW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MEMTIMUW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:9 - PLL System Clock Divisor"]
            #[inline]
            pub fn psysdiv(&self) -> PSYSDIVR {
                let bits = {
                    const MASK: u16 = 0x03ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                PSYSDIVR { bits }
            }
            #[doc = "Bits 10:19 - Oscillator System Clock Divisor"]
            #[inline]
            pub fn osysdiv(&self) -> OSYSDIVR {
                let bits = {
                    const MASK: u16 = 0x03ff;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                OSYSDIVR { bits }
            }
            #[doc = "Bits 20:23 - Oscillator Source"]
            #[inline]
            pub fn oscsrc(&self) -> OSCSRCR {
                OSCSRCR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 24:27 - PLL Source"]
            #[inline]
            pub fn pllsrc(&self) -> PLLSRCR {
                PLLSRCR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 28 - Use PLL"]
            #[inline]
            pub fn usepll(&self) -> USEPLLR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                USEPLLR { bits }
            }
            #[doc = "Bit 29 - Auto Clock Gating"]
            #[inline]
            pub fn acg(&self) -> ACGR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 29;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ACGR { bits }
            }
            #[doc = "Bit 30 - New PLLFREQ Accept"]
            #[inline]
            pub fn newfreq(&self) -> NEWFREQR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                NEWFREQR { bits }
            }
            #[doc = "Bit 31 - Memory Timing Register Update"]
            #[inline]
            pub fn memtimu(&self) -> MEMTIMUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MEMTIMUR { bits }
            }
        }
        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 0:9 - PLL System Clock Divisor"]
            #[inline]
            pub fn psysdiv(&mut self) -> _PSYSDIVW {
                _PSYSDIVW { w: self }
            }
            #[doc = "Bits 10:19 - Oscillator System Clock Divisor"]
            #[inline]
            pub fn osysdiv(&mut self) -> _OSYSDIVW {
                _OSYSDIVW { w: self }
            }
            #[doc = "Bits 20:23 - Oscillator Source"]
            #[inline]
            pub fn oscsrc(&mut self) -> _OSCSRCW {
                _OSCSRCW { w: self }
            }
            #[doc = "Bits 24:27 - PLL Source"]
            #[inline]
            pub fn pllsrc(&mut self) -> _PLLSRCW {
                _PLLSRCW { w: self }
            }
            #[doc = "Bit 28 - Use PLL"]
            #[inline]
            pub fn usepll(&mut self) -> _USEPLLW {
                _USEPLLW { w: self }
            }
            #[doc = "Bit 29 - Auto Clock Gating"]
            #[inline]
            pub fn acg(&mut self) -> _ACGW {
                _ACGW { w: self }
            }
            #[doc = "Bit 30 - New PLLFREQ Accept"]
            #[inline]
            pub fn newfreq(&mut self) -> _NEWFREQW {
                _NEWFREQW { w: self }
            }
            #[doc = "Bit 31 - Memory Timing Register Update"]
            #[inline]
            pub fn memtimu(&mut self) -> _MEMTIMUW {
                _MEMTIMUW { w: self }
            }
        }
    }
    #[doc = "Memory Timing Parameter Register 0 for Main Flash and EEPROM"]
    pub struct MEMTIM0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Memory Timing Parameter Register 0 for Main Flash and EEPROM"]
    pub mod memtim0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::MEMTIM0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct FWSR {
            bits: u8,
        }
        impl FWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct FBCER {
            bits: bool,
        }
        impl FBCER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `FBCHT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum FBCHTR {
            #[doc = "1/2 system clock period"]
            _0_5,
            #[doc = "1 system clock period"]
            _1,
            #[doc = "1.5 system clock periods"]
            _1_5,
            #[doc = "2 system clock periods"]
            _2,
            #[doc = "2.5 system clock periods"]
            _2_5,
            #[doc = "3 system clock periods"]
            _3,
            #[doc = "3.5 system clock periods"]
            _3_5,
            #[doc = "4 system clock periods"]
            _4,
            #[doc = "4.5 system clock periods"]
            _4_5,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl FBCHTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    FBCHTR::_0_5 => 0,
                    FBCHTR::_1 => 0x01,
                    FBCHTR::_1_5 => 0x02,
                    FBCHTR::_2 => 0x03,
                    FBCHTR::_2_5 => 0x04,
                    FBCHTR::_3 => 0x05,
                    FBCHTR::_3_5 => 0x06,
                    FBCHTR::_4 => 0x07,
                    FBCHTR::_4_5 => 0x08,
                    FBCHTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> FBCHTR {
                match value {
                    0 => FBCHTR::_0_5,
                    1 => FBCHTR::_1,
                    2 => FBCHTR::_1_5,
                    3 => FBCHTR::_2,
                    4 => FBCHTR::_2_5,
                    5 => FBCHTR::_3,
                    6 => FBCHTR::_3_5,
                    7 => FBCHTR::_4,
                    8 => FBCHTR::_4_5,
                    i => FBCHTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0_5`"]
            #[inline]
            pub fn is_0_5(&self) -> bool {
                *self == FBCHTR::_0_5
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == FBCHTR::_1
            }
            #[doc = "Checks if the value of the field is `_1_5`"]
            #[inline]
            pub fn is_1_5(&self) -> bool {
                *self == FBCHTR::_1_5
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == FBCHTR::_2
            }
            #[doc = "Checks if the value of the field is `_2_5`"]
            #[inline]
            pub fn is_2_5(&self) -> bool {
                *self == FBCHTR::_2_5
            }
            #[doc = "Checks if the value of the field is `_3`"]
            #[inline]
            pub fn is_3(&self) -> bool {
                *self == FBCHTR::_3
            }
            #[doc = "Checks if the value of the field is `_3_5`"]
            #[inline]
            pub fn is_3_5(&self) -> bool {
                *self == FBCHTR::_3_5
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == FBCHTR::_4
            }
            #[doc = "Checks if the value of the field is `_4_5`"]
            #[inline]
            pub fn is_4_5(&self) -> bool {
                *self == FBCHTR::_4_5
            }
        }
        #[doc = r" Value of the field"]
        pub struct EWSR {
            bits: u8,
        }
        impl EWSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct EBCER {
            bits: bool,
        }
        impl EBCER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `EBCHT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EBCHTR {
            #[doc = "1/2 system clock period"]
            _0_5,
            #[doc = "1 system clock period"]
            _1,
            #[doc = "1.5 system clock periods"]
            _1_5,
            #[doc = "2 system clock periods"]
            _2,
            #[doc = "2.5 system clock periods"]
            _2_5,
            #[doc = "3 system clock periods"]
            _3,
            #[doc = "3.5 system clock periods"]
            _3_5,
            #[doc = "4 system clock periods"]
            _4,
            #[doc = "4.5 system clock periods"]
            _4_5,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EBCHTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EBCHTR::_0_5 => 0,
                    EBCHTR::_1 => 0x01,
                    EBCHTR::_1_5 => 0x02,
                    EBCHTR::_2 => 0x03,
                    EBCHTR::_2_5 => 0x04,
                    EBCHTR::_3 => 0x05,
                    EBCHTR::_3_5 => 0x06,
                    EBCHTR::_4 => 0x07,
                    EBCHTR::_4_5 => 0x08,
                    EBCHTR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EBCHTR {
                match value {
                    0 => EBCHTR::_0_5,
                    1 => EBCHTR::_1,
                    2 => EBCHTR::_1_5,
                    3 => EBCHTR::_2,
                    4 => EBCHTR::_2_5,
                    5 => EBCHTR::_3,
                    6 => EBCHTR::_3_5,
                    7 => EBCHTR::_4,
                    8 => EBCHTR::_4_5,
                    i => EBCHTR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0_5`"]
            #[inline]
            pub fn is_0_5(&self) -> bool {
                *self == EBCHTR::_0_5
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == EBCHTR::_1
            }
            #[doc = "Checks if the value of the field is `_1_5`"]
            #[inline]
            pub fn is_1_5(&self) -> bool {
                *self == EBCHTR::_1_5
            }
            #[doc = "Checks if the value of the field is `_2`"]
            #[inline]
            pub fn is_2(&self) -> bool {
                *self == EBCHTR::_2
            }
            #[doc = "Checks if the value of the field is `_2_5`"]
            #[inline]
            pub fn is_2_5(&self) -> bool {
                *self == EBCHTR::_2_5
            }
            #[doc = "Checks if the value of the field is `_3`"]
            #[inline]
            pub fn is_3(&self) -> bool {
                *self == EBCHTR::_3
            }
            #[doc = "Checks if the value of the field is `_3_5`"]
            #[inline]
            pub fn is_3_5(&self) -> bool {
                *self == EBCHTR::_3_5
            }
            #[doc = "Checks if the value of the field is `_4`"]
            #[inline]
            pub fn is_4(&self) -> bool {
                *self == EBCHTR::_4
            }
            #[doc = "Checks if the value of the field is `_4_5`"]
            #[inline]
            pub fn is_4_5(&self) -> bool {
                *self == EBCHTR::_4_5
            }
        }
        #[doc = r" Proxy"]
        pub struct _FWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FWSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _FBCEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FBCEW<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `FBCHT`"]
        pub enum FBCHTW {
            #[doc = "1/2 system clock period"]
            _0_5,
            #[doc = "1 system clock period"]
            _1,
            #[doc = "1.5 system clock periods"]
            _1_5,
            #[doc = "2 system clock periods"]
            _2,
            #[doc = "2.5 system clock periods"]
            _2_5,
            #[doc = "3 system clock periods"]
            _3,
            #[doc = "3.5 system clock periods"]
            _3_5,
            #[doc = "4 system clock periods"]
            _4,
            #[doc = "4.5 system clock periods"]
            _4_5,
        }
        impl FBCHTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    FBCHTW::_0_5 => 0,
                    FBCHTW::_1 => 1,
                    FBCHTW::_1_5 => 2,
                    FBCHTW::_2 => 3,
                    FBCHTW::_2_5 => 4,
                    FBCHTW::_3 => 5,
                    FBCHTW::_3_5 => 6,
                    FBCHTW::_4 => 7,
                    FBCHTW::_4_5 => 8,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _FBCHTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FBCHTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: FBCHTW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "1/2 system clock period"]
            #[inline]
            pub fn _0_5(self) -> &'a mut W {
                self.variant(FBCHTW::_0_5)
            }
            #[doc = "1 system clock period"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(FBCHTW::_1)
            }
            #[doc = "1.5 system clock periods"]
            #[inline]
            pub fn _1_5(self) -> &'a mut W {
                self.variant(FBCHTW::_1_5)
            }
            #[doc = "2 system clock periods"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(FBCHTW::_2)
            }
            #[doc = "2.5 system clock periods"]
            #[inline]
            pub fn _2_5(self) -> &'a mut W {
                self.variant(FBCHTW::_2_5)
            }
            #[doc = "3 system clock periods"]
            #[inline]
            pub fn _3(self) -> &'a mut W {
                self.variant(FBCHTW::_3)
            }
            #[doc = "3.5 system clock periods"]
            #[inline]
            pub fn _3_5(self) -> &'a mut W {
                self.variant(FBCHTW::_3_5)
            }
            #[doc = "4 system clock periods"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(FBCHTW::_4)
            }
            #[doc = "4.5 system clock periods"]
            #[inline]
            pub fn _4_5(self) -> &'a mut W {
                self.variant(FBCHTW::_4_5)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EWSW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EWSW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _EBCEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EBCEW<'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 = 21;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `EBCHT`"]
        pub enum EBCHTW {
            #[doc = "1/2 system clock period"]
            _0_5,
            #[doc = "1 system clock period"]
            _1,
            #[doc = "1.5 system clock periods"]
            _1_5,
            #[doc = "2 system clock periods"]
            _2,
            #[doc = "2.5 system clock periods"]
            _2_5,
            #[doc = "3 system clock periods"]
            _3,
            #[doc = "3.5 system clock periods"]
            _3_5,
            #[doc = "4 system clock periods"]
            _4,
            #[doc = "4.5 system clock periods"]
            _4_5,
        }
        impl EBCHTW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EBCHTW::_0_5 => 0,
                    EBCHTW::_1 => 1,
                    EBCHTW::_1_5 => 2,
                    EBCHTW::_2 => 3,
                    EBCHTW::_2_5 => 4,
                    EBCHTW::_3 => 5,
                    EBCHTW::_3_5 => 6,
                    EBCHTW::_4 => 7,
                    EBCHTW::_4_5 => 8,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EBCHTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EBCHTW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EBCHTW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "1/2 system clock period"]
            #[inline]
            pub fn _0_5(self) -> &'a mut W {
                self.variant(EBCHTW::_0_5)
            }
            #[doc = "1 system clock period"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(EBCHTW::_1)
            }
            #[doc = "1.5 system clock periods"]
            #[inline]
            pub fn _1_5(self) -> &'a mut W {
                self.variant(EBCHTW::_1_5)
            }
            #[doc = "2 system clock periods"]
            #[inline]
            pub fn _2(self) -> &'a mut W {
                self.variant(EBCHTW::_2)
            }
            #[doc = "2.5 system clock periods"]
            #[inline]
            pub fn _2_5(self) -> &'a mut W {
                self.variant(EBCHTW::_2_5)
            }
            #[doc = "3 system clock periods"]
            #[inline]
            pub fn _3(self) -> &'a mut W {
                self.variant(EBCHTW::_3)
            }
            #[doc = "3.5 system clock periods"]
            #[inline]
            pub fn _3_5(self) -> &'a mut W {
                self.variant(EBCHTW::_3_5)
            }
            #[doc = "4 system clock periods"]
            #[inline]
            pub fn _4(self) -> &'a mut W {
                self.variant(EBCHTW::_4)
            }
            #[doc = "4.5 system clock periods"]
            #[inline]
            pub fn _4_5(self) -> &'a mut W {
                self.variant(EBCHTW::_4_5)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 22;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Flash Wait State"]
            #[inline]
            pub fn fws(&self) -> FWSR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                FWSR { bits }
            }
            #[doc = "Bit 5 - Flash Bank Clock Edge"]
            #[inline]
            pub fn fbce(&self) -> FBCER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FBCER { bits }
            }
            #[doc = "Bits 6:9 - Flash Bank Clock High Time"]
            #[inline]
            pub fn fbcht(&self) -> FBCHTR {
                FBCHTR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:19 - EEPROM Wait States"]
            #[inline]
            pub fn ews(&self) -> EWSR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                EWSR { bits }
            }
            #[doc = "Bit 21 - EEPROM Bank Clock Edge"]
            #[inline]
            pub fn ebce(&self) -> EBCER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 21;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                EBCER { bits }
            }
            #[doc = "Bits 22:25 - EEPROM Clock High Time"]
            #[inline]
            pub fn ebcht(&self) -> EBCHTR {
                EBCHTR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 22;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - Flash Wait State"]
            #[inline]
            pub fn fws(&mut self) -> _FWSW {
                _FWSW { w: self }
            }
            #[doc = "Bit 5 - Flash Bank Clock Edge"]
            #[inline]
            pub fn fbce(&mut self) -> _FBCEW {
                _FBCEW { w: self }
            }
            #[doc = "Bits 6:9 - Flash Bank Clock High Time"]
            #[inline]
            pub fn fbcht(&mut self) -> _FBCHTW {
                _FBCHTW { w: self }
            }
            #[doc = "Bits 16:19 - EEPROM Wait States"]
            #[inline]
            pub fn ews(&mut self) -> _EWSW {
                _EWSW { w: self }
            }
            #[doc = "Bit 21 - EEPROM Bank Clock Edge"]
            #[inline]
            pub fn ebce(&mut self) -> _EBCEW {
                _EBCEW { w: self }
            }
            #[doc = "Bits 22:25 - EEPROM Clock High Time"]
            #[inline]
            pub fn ebcht(&mut self) -> _EBCHTW {
                _EBCHTW { w: self }
            }
        }
    }
    #[doc = "Alternate Clock Configuration"]
    pub struct ALTCLKCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Alternate Clock Configuration"]
    pub mod altclkcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ALTCLKCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `ALTCLK`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ALTCLKR {
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "Hibernation Module Real-time clock output (RTCOSC)"]
            RTCOSC,
            #[doc = "Low-frequency internal oscillator (LFIOSC)"]
            LFIOSC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl ALTCLKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ALTCLKR::PIOSC => 0,
                    ALTCLKR::RTCOSC => 0x03,
                    ALTCLKR::LFIOSC => 0x04,
                    ALTCLKR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ALTCLKR {
                match value {
                    0 => ALTCLKR::PIOSC,
                    3 => ALTCLKR::RTCOSC,
                    4 => ALTCLKR::LFIOSC,
                    i => ALTCLKR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == ALTCLKR::PIOSC
            }
            #[doc = "Checks if the value of the field is `RTCOSC`"]
            #[inline]
            pub fn is_rtcosc(&self) -> bool {
                *self == ALTCLKR::RTCOSC
            }
            #[doc = "Checks if the value of the field is `LFIOSC`"]
            #[inline]
            pub fn is_lfiosc(&self) -> bool {
                *self == ALTCLKR::LFIOSC
            }
        }
        #[doc = "Values that can be written to the field `ALTCLK`"]
        pub enum ALTCLKW {
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "Hibernation Module Real-time clock output (RTCOSC)"]
            RTCOSC,
            #[doc = "Low-frequency internal oscillator (LFIOSC)"]
            LFIOSC,
        }
        impl ALTCLKW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ALTCLKW::PIOSC => 0,
                    ALTCLKW::RTCOSC => 3,
                    ALTCLKW::LFIOSC => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ALTCLKW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ALTCLKW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ALTCLKW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "PIOSC"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(ALTCLKW::PIOSC)
            }
            #[doc = "Hibernation Module Real-time clock output (RTCOSC)"]
            #[inline]
            pub fn rtcosc(self) -> &'a mut W {
                self.variant(ALTCLKW::RTCOSC)
            }
            #[doc = "Low-frequency internal oscillator (LFIOSC)"]
            #[inline]
            pub fn lfiosc(self) -> &'a mut W {
                self.variant(ALTCLKW::LFIOSC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Alternate Clock Source"]
            #[inline]
            pub fn altclk(&self) -> ALTCLKR {
                ALTCLKR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - Alternate Clock Source"]
            #[inline]
            pub fn altclk(&mut self) -> _ALTCLKW {
                _ALTCLKW { w: self }
            }
        }
    }
    #[doc = "Deep Sleep Clock Configuration Register"]
    pub struct DSCLKCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Deep Sleep Clock Configuration Register"]
    pub mod dsclkcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DSCLKCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DSSYSDIVR {
            bits: u16,
        }
        impl DSSYSDIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `DSOSCSRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum DSOSCSRCR {
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "LFIOSC"]
            LFIOSC,
            #[doc = "MOSC"]
            MOSC,
            #[doc = "Hibernation Module RTCOSC"]
            RTC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl DSOSCSRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    DSOSCSRCR::PIOSC => 0,
                    DSOSCSRCR::LFIOSC => 0x02,
                    DSOSCSRCR::MOSC => 0x03,
                    DSOSCSRCR::RTC => 0x04,
                    DSOSCSRCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> DSOSCSRCR {
                match value {
                    0 => DSOSCSRCR::PIOSC,
                    2 => DSOSCSRCR::LFIOSC,
                    3 => DSOSCSRCR::MOSC,
                    4 => DSOSCSRCR::RTC,
                    i => DSOSCSRCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == DSOSCSRCR::PIOSC
            }
            #[doc = "Checks if the value of the field is `LFIOSC`"]
            #[inline]
            pub fn is_lfiosc(&self) -> bool {
                *self == DSOSCSRCR::LFIOSC
            }
            #[doc = "Checks if the value of the field is `MOSC`"]
            #[inline]
            pub fn is_mosc(&self) -> bool {
                *self == DSOSCSRCR::MOSC
            }
            #[doc = "Checks if the value of the field is `RTC`"]
            #[inline]
            pub fn is_rtc(&self) -> bool {
                *self == DSOSCSRCR::RTC
            }
        }
        #[doc = r" Value of the field"]
        pub struct MOSCDPDR {
            bits: bool,
        }
        impl MOSCDPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct PIOSCPDR {
            bits: bool,
        }
        impl PIOSCPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSSYSDIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSSYSDIVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x03ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `DSOSCSRC`"]
        pub enum DSOSCSRCW {
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "LFIOSC"]
            LFIOSC,
            #[doc = "MOSC"]
            MOSC,
            #[doc = "Hibernation Module RTCOSC"]
            RTC,
        }
        impl DSOSCSRCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    DSOSCSRCW::PIOSC => 0,
                    DSOSCSRCW::LFIOSC => 2,
                    DSOSCSRCW::MOSC => 3,
                    DSOSCSRCW::RTC => 4,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _DSOSCSRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DSOSCSRCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: DSOSCSRCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "PIOSC"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(DSOSCSRCW::PIOSC)
            }
            #[doc = "LFIOSC"]
            #[inline]
            pub fn lfiosc(self) -> &'a mut W {
                self.variant(DSOSCSRCW::LFIOSC)
            }
            #[doc = "MOSC"]
            #[inline]
            pub fn mosc(self) -> &'a mut W {
                self.variant(DSOSCSRCW::MOSC)
            }
            #[doc = "Hibernation Module RTCOSC"]
            #[inline]
            pub fn rtc(self) -> &'a mut W {
                self.variant(DSOSCSRCW::RTC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MOSCDPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MOSCDPDW<'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 = 30;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PIOSCPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PIOSCPDW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:9 - Deep Sleep Clock Divisor"]
            #[inline]
            pub fn dssysdiv(&self) -> DSSYSDIVR {
                let bits = {
                    const MASK: u16 = 0x03ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                DSSYSDIVR { bits }
            }
            #[doc = "Bits 20:23 - Deep Sleep Oscillator Source"]
            #[inline]
            pub fn dsoscsrc(&self) -> DSOSCSRCR {
                DSOSCSRCR::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 30 - MOSC Disable Power Down"]
            #[inline]
            pub fn moscdpd(&self) -> MOSCDPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 30;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MOSCDPDR { bits }
            }
            #[doc = "Bit 31 - PIOSC Power Down"]
            #[inline]
            pub fn pioscpd(&self) -> PIOSCPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PIOSCPDR { bits }
            }
        }
        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 0:9 - Deep Sleep Clock Divisor"]
            #[inline]
            pub fn dssysdiv(&mut self) -> _DSSYSDIVW {
                _DSSYSDIVW { w: self }
            }
            #[doc = "Bits 20:23 - Deep Sleep Oscillator Source"]
            #[inline]
            pub fn dsoscsrc(&mut self) -> _DSOSCSRCW {
                _DSOSCSRCW { w: self }
            }
            #[doc = "Bit 30 - MOSC Disable Power Down"]
            #[inline]
            pub fn moscdpd(&mut self) -> _MOSCDPDW {
                _MOSCDPDW { w: self }
            }
            #[doc = "Bit 31 - PIOSC Power Down"]
            #[inline]
            pub fn pioscpd(&mut self) -> _PIOSCPDW {
                _PIOSCPDW { w: self }
            }
        }
    }
    #[doc = "Divisor and Source Clock Configuration"]
    pub struct DIVSCLK {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Divisor and Source Clock Configuration"]
    pub mod divsclk {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DIVSCLK {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DIVR {
            bits: u8,
        }
        impl DIVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `SRC`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SRCR {
            #[doc = "System Clock"]
            SYSCLK,
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "MOSC"]
            MOSC,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SRCR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SRCR::SYSCLK => 0,
                    SRCR::PIOSC => 0x01,
                    SRCR::MOSC => 0x02,
                    SRCR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SRCR {
                match value {
                    0 => SRCR::SYSCLK,
                    1 => SRCR::PIOSC,
                    2 => SRCR::MOSC,
                    i => SRCR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSCLK`"]
            #[inline]
            pub fn is_sysclk(&self) -> bool {
                *self == SRCR::SYSCLK
            }
            #[doc = "Checks if the value of the field is `PIOSC`"]
            #[inline]
            pub fn is_piosc(&self) -> bool {
                *self == SRCR::PIOSC
            }
            #[doc = "Checks if the value of the field is `MOSC`"]
            #[inline]
            pub fn is_mosc(&self) -> bool {
                *self == SRCR::MOSC
            }
        }
        #[doc = r" Value of the field"]
        pub struct ENR {
            bits: bool,
        }
        impl ENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _DIVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DIVW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `SRC`"]
        pub enum SRCW {
            #[doc = "System Clock"]
            SYSCLK,
            #[doc = "PIOSC"]
            PIOSC,
            #[doc = "MOSC"]
            MOSC,
        }
        impl SRCW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SRCW::SYSCLK => 0,
                    SRCW::PIOSC => 1,
                    SRCW::MOSC => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SRCW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SRCW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SRCW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "System Clock"]
            #[inline]
            pub fn sysclk(self) -> &'a mut W {
                self.variant(SRCW::SYSCLK)
            }
            #[doc = "PIOSC"]
            #[inline]
            pub fn piosc(self) -> &'a mut W {
                self.variant(SRCW::PIOSC)
            }
            #[doc = "MOSC"]
            #[inline]
            pub fn mosc(self) -> &'a mut W {
                self.variant(SRCW::MOSC)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - Divisor Value"]
            #[inline]
            pub fn div(&self) -> DIVR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DIVR { bits }
            }
            #[doc = "Bits 16:17 - Clock Source"]
            #[inline]
            pub fn src(&self) -> SRCR {
                SRCR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 31 - DIVSCLK Enable"]
            #[inline]
            pub fn en(&self) -> ENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ENR { bits }
            }
        }
        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 0:7 - Divisor Value"]
            #[inline]
            pub fn div(&mut self) -> _DIVW {
                _DIVW { w: self }
            }
            #[doc = "Bits 16:17 - Clock Source"]
            #[inline]
            pub fn src(&mut self) -> _SRCW {
                _SRCW { w: self }
            }
            #[doc = "Bit 31 - DIVSCLK Enable"]
            #[inline]
            pub fn en(&mut self) -> _ENW {
                _ENW { w: self }
            }
        }
    }
    #[doc = "System Properties"]
    pub struct SYSPROP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "System Properties"]
    pub mod sysprop {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::SYSPROP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FPUR {
            bits: bool,
        }
        impl FPUR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - FPU Present"]
            #[inline]
            pub fn fpu(&self) -> FPUR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FPUR { bits }
            }
        }
    }
    #[doc = "Precision Internal Oscillator Calibration"]
    pub struct PIOSCCAL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Precision Internal Oscillator Calibration"]
    pub mod piosccal {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PIOSCCAL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct UTR {
            bits: u8,
        }
        impl UTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct UPDATER {
            bits: bool,
        }
        impl UPDATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct CALR {
            bits: bool,
        }
        impl CALR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct UTENR {
            bits: bool,
        }
        impl UTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _UTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x7f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UPDATEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UPDATEW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CALW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CALW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _UTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _UTENW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:6 - User Trim Value"]
            #[inline]
            pub fn ut(&self) -> UTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                UTR { bits }
            }
            #[doc = "Bit 8 - Update Trim"]
            #[inline]
            pub fn update(&self) -> UPDATER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UPDATER { bits }
            }
            #[doc = "Bit 9 - Start Calibration"]
            #[inline]
            pub fn cal(&self) -> CALR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                CALR { bits }
            }
            #[doc = "Bit 31 - Use User Trim Value"]
            #[inline]
            pub fn uten(&self) -> UTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                UTENR { bits }
            }
        }
        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 0:6 - User Trim Value"]
            #[inline]
            pub fn ut(&mut self) -> _UTW {
                _UTW { w: self }
            }
            #[doc = "Bit 8 - Update Trim"]
            #[inline]
            pub fn update(&mut self) -> _UPDATEW {
                _UPDATEW { w: self }
            }
            #[doc = "Bit 9 - Start Calibration"]
            #[inline]
            pub fn cal(&mut self) -> _CALW {
                _CALW { w: self }
            }
            #[doc = "Bit 31 - Use User Trim Value"]
            #[inline]
            pub fn uten(&mut self) -> _UTENW {
                _UTENW { w: self }
            }
        }
    }
    #[doc = "Precision Internal Oscillator Statistics"]
    pub struct PIOSCSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Precision Internal Oscillator Statistics"]
    pub mod pioscstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PIOSCSTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct CTR {
            bits: u8,
        }
        impl CTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = "Possible values of the field `CR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CRR {
            #[doc = "Calibration has not been attempted"]
            CRNONE,
            #[doc = "The last calibration operation completed to meet 1% accuracy"]
            CRPASS,
            #[doc = "The last calibration operation failed to meet 1% accuracy"]
            CRFAIL,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl CRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    CRR::CRNONE => 0,
                    CRR::CRPASS => 0x01,
                    CRR::CRFAIL => 0x02,
                    CRR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> CRR {
                match value {
                    0 => CRR::CRNONE,
                    1 => CRR::CRPASS,
                    2 => CRR::CRFAIL,
                    i => CRR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `CRNONE`"]
            #[inline]
            pub fn is_crnone(&self) -> bool {
                *self == CRR::CRNONE
            }
            #[doc = "Checks if the value of the field is `CRPASS`"]
            #[inline]
            pub fn is_crpass(&self) -> bool {
                *self == CRR::CRPASS
            }
            #[doc = "Checks if the value of the field is `CRFAIL`"]
            #[inline]
            pub fn is_crfail(&self) -> bool {
                *self == CRR::CRFAIL
            }
        }
        #[doc = r" Value of the field"]
        pub struct DTR {
            bits: u8,
        }
        impl DTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:6 - Calibration Trim Value"]
            #[inline]
            pub fn ct(&self) -> CTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CTR { bits }
            }
            #[doc = "Bits 8:9 - Calibration Result"]
            #[inline]
            pub fn cr(&self) -> CRR {
                CRR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:22 - Default Trim Value"]
            #[inline]
            pub fn dt(&self) -> DTR {
                let bits = {
                    const MASK: u8 = 0x7f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DTR { bits }
            }
        }
    }
    #[doc = "PLL Frequency 0"]
    pub struct PLLFREQ0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PLL Frequency 0"]
    pub mod pllfreq0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PLLFREQ0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct MINTR {
            bits: u16,
        }
        impl MINTR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct MFRACR {
            bits: u16,
        }
        impl MFRACR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u16 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct PLLPWRR {
            bits: bool,
        }
        impl PLLPWRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _MINTW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MINTW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x03ff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _MFRACW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MFRACW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u16) -> &'a mut W {
                const MASK: u16 = 0x03ff;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _PLLPWRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PLLPWRW<'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 = 23;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:9 - PLL M Integer Value"]
            #[inline]
            pub fn mint(&self) -> MINTR {
                let bits = {
                    const MASK: u16 = 0x03ff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MINTR { bits }
            }
            #[doc = "Bits 10:19 - PLL M Fractional Value"]
            #[inline]
            pub fn mfrac(&self) -> MFRACR {
                let bits = {
                    const MASK: u16 = 0x03ff;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u16
                };
                MFRACR { bits }
            }
            #[doc = "Bit 23 - PLL Power"]
            #[inline]
            pub fn pllpwr(&self) -> PLLPWRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 23;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                PLLPWRR { bits }
            }
        }
        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 0:9 - PLL M Integer Value"]
            #[inline]
            pub fn mint(&mut self) -> _MINTW {
                _MINTW { w: self }
            }
            #[doc = "Bits 10:19 - PLL M Fractional Value"]
            #[inline]
            pub fn mfrac(&mut self) -> _MFRACW {
                _MFRACW { w: self }
            }
            #[doc = "Bit 23 - PLL Power"]
            #[inline]
            pub fn pllpwr(&mut self) -> _PLLPWRW {
                _PLLPWRW { w: self }
            }
        }
    }
    #[doc = "PLL Frequency 1"]
    pub struct PLLFREQ1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PLL Frequency 1"]
    pub mod pllfreq1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PLLFREQ1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct NR {
            bits: u8,
        }
        impl NR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct QR {
            bits: u8,
        }
        impl QR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _NW<'a> {
            w: &'a mut W,
        }
        impl<'a> _NW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _QW<'a> {
            w: &'a mut W,
        }
        impl<'a> _QW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x1f;
                const OFFSET: u8 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:4 - PLL N Value"]
            #[inline]
            pub fn n(&self) -> NR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                NR { bits }
            }
            #[doc = "Bits 8:12 - PLL Q Value"]
            #[inline]
            pub fn q(&self) -> QR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                QR { bits }
            }
        }
        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 0:4 - PLL N Value"]
            #[inline]
            pub fn n(&mut self) -> _NW {
                _NW { w: self }
            }
            #[doc = "Bits 8:12 - PLL Q Value"]
            #[inline]
            pub fn q(&mut self) -> _QW {
                _QW { w: self }
            }
        }
    }
    #[doc = "PLL Status"]
    pub struct PLLSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "PLL Status"]
    pub mod pllstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PLLSTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct LOCKR {
            bits: bool,
        }
        impl LOCKR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PLL Lock"]
            #[inline]
            pub fn lock(&self) -> LOCKR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LOCKR { bits }
            }
        }
    }
    #[doc = "Sleep Power Configuration"]
    pub struct SLPPWRCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Sleep Power Configuration"]
    pub mod slppwrcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SLPPWRCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SRAMPM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SRAMPMR {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Standby Mode"]
            SBY,
            #[doc = "Low Power Mode"]
            LP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SRAMPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SRAMPMR::NRM => 0,
                    SRAMPMR::SBY => 0x01,
                    SRAMPMR::LP => 0x03,
                    SRAMPMR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SRAMPMR {
                match value {
                    0 => SRAMPMR::NRM,
                    1 => SRAMPMR::SBY,
                    3 => SRAMPMR::LP,
                    i => SRAMPMR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NRM`"]
            #[inline]
            pub fn is_nrm(&self) -> bool {
                *self == SRAMPMR::NRM
            }
            #[doc = "Checks if the value of the field is `SBY`"]
            #[inline]
            pub fn is_sby(&self) -> bool {
                *self == SRAMPMR::SBY
            }
            #[doc = "Checks if the value of the field is `LP`"]
            #[inline]
            pub fn is_lp(&self) -> bool {
                *self == SRAMPMR::LP
            }
        }
        #[doc = "Possible values of the field `FLASHPM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum FLASHPMR {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Low Power Mode"]
            SLP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl FLASHPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    FLASHPMR::NRM => 0,
                    FLASHPMR::SLP => 0x02,
                    FLASHPMR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> FLASHPMR {
                match value {
                    0 => FLASHPMR::NRM,
                    2 => FLASHPMR::SLP,
                    i => FLASHPMR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NRM`"]
            #[inline]
            pub fn is_nrm(&self) -> bool {
                *self == FLASHPMR::NRM
            }
            #[doc = "Checks if the value of the field is `SLP`"]
            #[inline]
            pub fn is_slp(&self) -> bool {
                *self == FLASHPMR::SLP
            }
        }
        #[doc = "Values that can be written to the field `SRAMPM`"]
        pub enum SRAMPMW {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Standby Mode"]
            SBY,
            #[doc = "Low Power Mode"]
            LP,
        }
        impl SRAMPMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SRAMPMW::NRM => 0,
                    SRAMPMW::SBY => 1,
                    SRAMPMW::LP => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SRAMPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SRAMPMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SRAMPMW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Active Mode"]
            #[inline]
            pub fn nrm(self) -> &'a mut W {
                self.variant(SRAMPMW::NRM)
            }
            #[doc = "Standby Mode"]
            #[inline]
            pub fn sby(self) -> &'a mut W {
                self.variant(SRAMPMW::SBY)
            }
            #[doc = "Low Power Mode"]
            #[inline]
            pub fn lp(self) -> &'a mut W {
                self.variant(SRAMPMW::LP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `FLASHPM`"]
        pub enum FLASHPMW {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Low Power Mode"]
            SLP,
        }
        impl FLASHPMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    FLASHPMW::NRM => 0,
                    FLASHPMW::SLP => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLASHPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLASHPMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: FLASHPMW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Active Mode"]
            #[inline]
            pub fn nrm(self) -> &'a mut W {
                self.variant(FLASHPMW::NRM)
            }
            #[doc = "Low Power Mode"]
            #[inline]
            pub fn slp(self) -> &'a mut W {
                self.variant(FLASHPMW::SLP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - SRAM Power Modes"]
            #[inline]
            pub fn srampm(&self) -> SRAMPMR {
                SRAMPMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Flash Power Modes"]
            #[inline]
            pub fn flashpm(&self) -> FLASHPMR {
                FLASHPMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - SRAM Power Modes"]
            #[inline]
            pub fn srampm(&mut self) -> _SRAMPMW {
                _SRAMPMW { w: self }
            }
            #[doc = "Bits 4:5 - Flash Power Modes"]
            #[inline]
            pub fn flashpm(&mut self) -> _FLASHPMW {
                _FLASHPMW { w: self }
            }
        }
    }
    #[doc = "Deep-Sleep Power Configuration"]
    pub struct DSLPPWRCFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Deep-Sleep Power Configuration"]
    pub mod dslppwrcfg {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DSLPPWRCFG {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `SRAMPM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum SRAMPMR {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Standby Mode"]
            SBY,
            #[doc = "Low Power Mode"]
            LP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl SRAMPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    SRAMPMR::NRM => 0,
                    SRAMPMR::SBY => 0x01,
                    SRAMPMR::LP => 0x03,
                    SRAMPMR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> SRAMPMR {
                match value {
                    0 => SRAMPMR::NRM,
                    1 => SRAMPMR::SBY,
                    3 => SRAMPMR::LP,
                    i => SRAMPMR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NRM`"]
            #[inline]
            pub fn is_nrm(&self) -> bool {
                *self == SRAMPMR::NRM
            }
            #[doc = "Checks if the value of the field is `SBY`"]
            #[inline]
            pub fn is_sby(&self) -> bool {
                *self == SRAMPMR::SBY
            }
            #[doc = "Checks if the value of the field is `LP`"]
            #[inline]
            pub fn is_lp(&self) -> bool {
                *self == SRAMPMR::LP
            }
        }
        #[doc = "Possible values of the field `FLASHPM`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum FLASHPMR {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Low Power Mode"]
            SLP,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl FLASHPMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    FLASHPMR::NRM => 0,
                    FLASHPMR::SLP => 0x02,
                    FLASHPMR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> FLASHPMR {
                match value {
                    0 => FLASHPMR::NRM,
                    2 => FLASHPMR::SLP,
                    i => FLASHPMR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `NRM`"]
            #[inline]
            pub fn is_nrm(&self) -> bool {
                *self == FLASHPMR::NRM
            }
            #[doc = "Checks if the value of the field is `SLP`"]
            #[inline]
            pub fn is_slp(&self) -> bool {
                *self == FLASHPMR::SLP
            }
        }
        #[doc = r" Value of the field"]
        pub struct TSPDR {
            bits: bool,
        }
        impl TSPDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct LDOSMR {
            bits: bool,
        }
        impl LDOSMR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `SRAMPM`"]
        pub enum SRAMPMW {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Standby Mode"]
            SBY,
            #[doc = "Low Power Mode"]
            LP,
        }
        impl SRAMPMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    SRAMPMW::NRM => 0,
                    SRAMPMW::SBY => 1,
                    SRAMPMW::LP => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _SRAMPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SRAMPMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: SRAMPMW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Active Mode"]
            #[inline]
            pub fn nrm(self) -> &'a mut W {
                self.variant(SRAMPMW::NRM)
            }
            #[doc = "Standby Mode"]
            #[inline]
            pub fn sby(self) -> &'a mut W {
                self.variant(SRAMPMW::SBY)
            }
            #[doc = "Low Power Mode"]
            #[inline]
            pub fn lp(self) -> &'a mut W {
                self.variant(SRAMPMW::LP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `FLASHPM`"]
        pub enum FLASHPMW {
            #[doc = "Active Mode"]
            NRM,
            #[doc = "Low Power Mode"]
            SLP,
        }
        impl FLASHPMW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    FLASHPMW::NRM => 0,
                    FLASHPMW::SLP => 2,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _FLASHPMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _FLASHPMW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: FLASHPMW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Active Mode"]
            #[inline]
            pub fn nrm(self) -> &'a mut W {
                self.variant(FLASHPMW::NRM)
            }
            #[doc = "Low Power Mode"]
            #[inline]
            pub fn slp(self) -> &'a mut W {
                self.variant(FLASHPMW::SLP)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _TSPDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TSPDW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _LDOSMW<'a> {
            w: &'a mut W,
        }
        impl<'a> _LDOSMW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - SRAM Power Modes"]
            #[inline]
            pub fn srampm(&self) -> SRAMPMR {
                SRAMPMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Flash Power Modes"]
            #[inline]
            pub fn flashpm(&self) -> FLASHPMR {
                FLASHPMR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 8 - Temperature Sense Power Down"]
            #[inline]
            pub fn tspd(&self) -> TSPDR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                TSPDR { bits }
            }
            #[doc = "Bit 9 - LDO Sleep Mode"]
            #[inline]
            pub fn ldosm(&self) -> LDOSMR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                LDOSMR { bits }
            }
        }
        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 0:1 - SRAM Power Modes"]
            #[inline]
            pub fn srampm(&mut self) -> _SRAMPMW {
                _SRAMPMW { w: self }
            }
            #[doc = "Bits 4:5 - Flash Power Modes"]
            #[inline]
            pub fn flashpm(&mut self) -> _FLASHPMW {
                _FLASHPMW { w: self }
            }
            #[doc = "Bit 8 - Temperature Sense Power Down"]
            #[inline]
            pub fn tspd(&mut self) -> _TSPDW {
                _TSPDW { w: self }
            }
            #[doc = "Bit 9 - LDO Sleep Mode"]
            #[inline]
            pub fn ldosm(&mut self) -> _LDOSMW {
                _LDOSMW { w: self }
            }
        }
    }
    #[doc = "Non-Volatile Memory Information"]
    pub struct NVMSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Non-Volatile Memory Information"]
    pub mod nvmstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::NVMSTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct FWBR {
            bits: bool,
        }
        impl FWBR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 32 Word Flash Write Buffer Available"]
            #[inline]
            pub fn fwb(&self) -> FWBR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                FWBR { bits }
            }
        }
    }
    #[doc = "LDO Sleep Power Control"]
    pub struct LDOSPCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "LDO Sleep Power Control"]
    pub mod ldospctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LDOSPCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `VLDO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VLDOR {
            #[doc = "0.90 V"]
            _0_90V,
            #[doc = "0.95 V"]
            _0_95V,
            #[doc = "1.00 V"]
            _1_00V,
            #[doc = "1.05 V"]
            _1_05V,
            #[doc = "1.10 V"]
            _1_10V,
            #[doc = "1.15 V"]
            _1_15V,
            #[doc = "1.20 V"]
            _1_20V,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl VLDOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VLDOR::_0_90V => 0x12,
                    VLDOR::_0_95V => 0x13,
                    VLDOR::_1_00V => 0x14,
                    VLDOR::_1_05V => 0x15,
                    VLDOR::_1_10V => 0x16,
                    VLDOR::_1_15V => 0x17,
                    VLDOR::_1_20V => 0x18,
                    VLDOR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VLDOR {
                match value {
                    18 => VLDOR::_0_90V,
                    19 => VLDOR::_0_95V,
                    20 => VLDOR::_1_00V,
                    21 => VLDOR::_1_05V,
                    22 => VLDOR::_1_10V,
                    23 => VLDOR::_1_15V,
                    24 => VLDOR::_1_20V,
                    i => VLDOR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0_90V`"]
            #[inline]
            pub fn is_0_90v(&self) -> bool {
                *self == VLDOR::_0_90V
            }
            #[doc = "Checks if the value of the field is `_0_95V`"]
            #[inline]
            pub fn is_0_95v(&self) -> bool {
                *self == VLDOR::_0_95V
            }
            #[doc = "Checks if the value of the field is `_1_00V`"]
            #[inline]
            pub fn is_1_00v(&self) -> bool {
                *self == VLDOR::_1_00V
            }
            #[doc = "Checks if the value of the field is `_1_05V`"]
            #[inline]
            pub fn is_1_05v(&self) -> bool {
                *self == VLDOR::_1_05V
            }
            #[doc = "Checks if the value of the field is `_1_10V`"]
            #[inline]
            pub fn is_1_10v(&self) -> bool {
                *self == VLDOR::_1_10V
            }
            #[doc = "Checks if the value of the field is `_1_15V`"]
            #[inline]
            pub fn is_1_15v(&self) -> bool {
                *self == VLDOR::_1_15V
            }
            #[doc = "Checks if the value of the field is `_1_20V`"]
            #[inline]
            pub fn is_1_20v(&self) -> bool {
                *self == VLDOR::_1_20V
            }
        }
        #[doc = r" Value of the field"]
        pub struct VADJENR {
            bits: bool,
        }
        impl VADJENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `VLDO`"]
        pub enum VLDOW {
            #[doc = "0.90 V"]
            _0_90V,
            #[doc = "0.95 V"]
            _0_95V,
            #[doc = "1.00 V"]
            _1_00V,
            #[doc = "1.05 V"]
            _1_05V,
            #[doc = "1.10 V"]
            _1_10V,
            #[doc = "1.15 V"]
            _1_15V,
            #[doc = "1.20 V"]
            _1_20V,
        }
        impl VLDOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VLDOW::_0_90V => 18,
                    VLDOW::_0_95V => 19,
                    VLDOW::_1_00V => 20,
                    VLDOW::_1_05V => 21,
                    VLDOW::_1_10V => 22,
                    VLDOW::_1_15V => 23,
                    VLDOW::_1_20V => 24,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLDOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLDOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VLDOW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "0.90 V"]
            #[inline]
            pub fn _0_90v(self) -> &'a mut W {
                self.variant(VLDOW::_0_90V)
            }
            #[doc = "0.95 V"]
            #[inline]
            pub fn _0_95v(self) -> &'a mut W {
                self.variant(VLDOW::_0_95V)
            }
            #[doc = "1.00 V"]
            #[inline]
            pub fn _1_00v(self) -> &'a mut W {
                self.variant(VLDOW::_1_00V)
            }
            #[doc = "1.05 V"]
            #[inline]
            pub fn _1_05v(self) -> &'a mut W {
                self.variant(VLDOW::_1_05V)
            }
            #[doc = "1.10 V"]
            #[inline]
            pub fn _1_10v(self) -> &'a mut W {
                self.variant(VLDOW::_1_10V)
            }
            #[doc = "1.15 V"]
            #[inline]
            pub fn _1_15v(self) -> &'a mut W {
                self.variant(VLDOW::_1_15V)
            }
            #[doc = "1.20 V"]
            #[inline]
            pub fn _1_20v(self) -> &'a mut W {
                self.variant(VLDOW::_1_20V)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VADJENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VADJENW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - LDO Output Voltage"]
            #[inline]
            pub fn vldo(&self) -> VLDOR {
                VLDOR::_from({
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 31 - Voltage Adjust Enable"]
            #[inline]
            pub fn vadjen(&self) -> VADJENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VADJENR { bits }
            }
        }
        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 0:7 - LDO Output Voltage"]
            #[inline]
            pub fn vldo(&mut self) -> _VLDOW {
                _VLDOW { w: self }
            }
            #[doc = "Bit 31 - Voltage Adjust Enable"]
            #[inline]
            pub fn vadjen(&mut self) -> _VADJENW {
                _VADJENW { w: self }
            }
        }
    }
    #[doc = "LDO Deep-Sleep Power Control"]
    pub struct LDODPCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "LDO Deep-Sleep Power Control"]
    pub mod ldodpctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::LDODPCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `VLDO`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum VLDOR {
            #[doc = "0.90 V"]
            _0_90V,
            #[doc = "0.95 V"]
            _0_95V,
            #[doc = "1.00 V"]
            _1_00V,
            #[doc = "1.05 V"]
            _1_05V,
            #[doc = "1.10 V"]
            _1_10V,
            #[doc = "1.15 V"]
            _1_15V,
            #[doc = "1.20 V"]
            _1_20V,
            #[doc = "1.25 V"]
            _1_25V,
            #[doc = "1.30 V"]
            _1_30V,
            #[doc = "1.35 V"]
            _1_35V,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl VLDOR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    VLDOR::_0_90V => 0x12,
                    VLDOR::_0_95V => 0x13,
                    VLDOR::_1_00V => 0x14,
                    VLDOR::_1_05V => 0x15,
                    VLDOR::_1_10V => 0x16,
                    VLDOR::_1_15V => 0x17,
                    VLDOR::_1_20V => 0x18,
                    VLDOR::_1_25V => 0x19,
                    VLDOR::_1_30V => 0x1a,
                    VLDOR::_1_35V => 0x1b,
                    VLDOR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> VLDOR {
                match value {
                    18 => VLDOR::_0_90V,
                    19 => VLDOR::_0_95V,
                    20 => VLDOR::_1_00V,
                    21 => VLDOR::_1_05V,
                    22 => VLDOR::_1_10V,
                    23 => VLDOR::_1_15V,
                    24 => VLDOR::_1_20V,
                    25 => VLDOR::_1_25V,
                    26 => VLDOR::_1_30V,
                    27 => VLDOR::_1_35V,
                    i => VLDOR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `_0_90V`"]
            #[inline]
            pub fn is_0_90v(&self) -> bool {
                *self == VLDOR::_0_90V
            }
            #[doc = "Checks if the value of the field is `_0_95V`"]
            #[inline]
            pub fn is_0_95v(&self) -> bool {
                *self == VLDOR::_0_95V
            }
            #[doc = "Checks if the value of the field is `_1_00V`"]
            #[inline]
            pub fn is_1_00v(&self) -> bool {
                *self == VLDOR::_1_00V
            }
            #[doc = "Checks if the value of the field is `_1_05V`"]
            #[inline]
            pub fn is_1_05v(&self) -> bool {
                *self == VLDOR::_1_05V
            }
            #[doc = "Checks if the value of the field is `_1_10V`"]
            #[inline]
            pub fn is_1_10v(&self) -> bool {
                *self == VLDOR::_1_10V
            }
            #[doc = "Checks if the value of the field is `_1_15V`"]
            #[inline]
            pub fn is_1_15v(&self) -> bool {
                *self == VLDOR::_1_15V
            }
            #[doc = "Checks if the value of the field is `_1_20V`"]
            #[inline]
            pub fn is_1_20v(&self) -> bool {
                *self == VLDOR::_1_20V
            }
            #[doc = "Checks if the value of the field is `_1_25V`"]
            #[inline]
            pub fn is_1_25v(&self) -> bool {
                *self == VLDOR::_1_25V
            }
            #[doc = "Checks if the value of the field is `_1_30V`"]
            #[inline]
            pub fn is_1_30v(&self) -> bool {
                *self == VLDOR::_1_30V
            }
            #[doc = "Checks if the value of the field is `_1_35V`"]
            #[inline]
            pub fn is_1_35v(&self) -> bool {
                *self == VLDOR::_1_35V
            }
        }
        #[doc = r" Value of the field"]
        pub struct VADJENR {
            bits: bool,
        }
        impl VADJENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Values that can be written to the field `VLDO`"]
        pub enum VLDOW {
            #[doc = "0.90 V"]
            _0_90V,
            #[doc = "0.95 V"]
            _0_95V,
            #[doc = "1.00 V"]
            _1_00V,
            #[doc = "1.05 V"]
            _1_05V,
            #[doc = "1.10 V"]
            _1_10V,
            #[doc = "1.15 V"]
            _1_15V,
            #[doc = "1.20 V"]
            _1_20V,
            #[doc = "1.25 V"]
            _1_25V,
            #[doc = "1.30 V"]
            _1_30V,
            #[doc = "1.35 V"]
            _1_35V,
        }
        impl VLDOW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    VLDOW::_0_90V => 18,
                    VLDOW::_0_95V => 19,
                    VLDOW::_1_00V => 20,
                    VLDOW::_1_05V => 21,
                    VLDOW::_1_10V => 22,
                    VLDOW::_1_15V => 23,
                    VLDOW::_1_20V => 24,
                    VLDOW::_1_25V => 25,
                    VLDOW::_1_30V => 26,
                    VLDOW::_1_35V => 27,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _VLDOW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VLDOW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: VLDOW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "0.90 V"]
            #[inline]
            pub fn _0_90v(self) -> &'a mut W {
                self.variant(VLDOW::_0_90V)
            }
            #[doc = "0.95 V"]
            #[inline]
            pub fn _0_95v(self) -> &'a mut W {
                self.variant(VLDOW::_0_95V)
            }
            #[doc = "1.00 V"]
            #[inline]
            pub fn _1_00v(self) -> &'a mut W {
                self.variant(VLDOW::_1_00V)
            }
            #[doc = "1.05 V"]
            #[inline]
            pub fn _1_05v(self) -> &'a mut W {
                self.variant(VLDOW::_1_05V)
            }
            #[doc = "1.10 V"]
            #[inline]
            pub fn _1_10v(self) -> &'a mut W {
                self.variant(VLDOW::_1_10V)
            }
            #[doc = "1.15 V"]
            #[inline]
            pub fn _1_15v(self) -> &'a mut W {
                self.variant(VLDOW::_1_15V)
            }
            #[doc = "1.20 V"]
            #[inline]
            pub fn _1_20v(self) -> &'a mut W {
                self.variant(VLDOW::_1_20V)
            }
            #[doc = "1.25 V"]
            #[inline]
            pub fn _1_25v(self) -> &'a mut W {
                self.variant(VLDOW::_1_25V)
            }
            #[doc = "1.30 V"]
            #[inline]
            pub fn _1_30v(self) -> &'a mut W {
                self.variant(VLDOW::_1_30V)
            }
            #[doc = "1.35 V"]
            #[inline]
            pub fn _1_35v(self) -> &'a mut W {
                self.variant(VLDOW::_1_35V)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _VADJENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _VADJENW<'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 = 31;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:7 - LDO Output Voltage"]
            #[inline]
            pub fn vldo(&self) -> VLDOR {
                VLDOR::_from({
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 31 - Voltage Adjust Enable"]
            #[inline]
            pub fn vadjen(&self) -> VADJENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 31;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                VADJENR { bits }
            }
        }
        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 0:7 - LDO Output Voltage"]
            #[inline]
            pub fn vldo(&mut self) -> _VLDOW {
                _VLDOW { w: self }
            }
            #[doc = "Bit 31 - Voltage Adjust Enable"]
            #[inline]
            pub fn vadjen(&mut self) -> _VADJENW {
                _VADJENW { w: self }
            }
        }
    }
    #[doc = "Reset Behavior Control Register"]
    pub struct RESBEHAVCTL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Reset Behavior Control Register"]
    pub mod resbehavctl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RESBEHAVCTL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `EXTRES`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum EXTRESR {
            #[doc = "External RST assertion issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "External RST assertion issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl EXTRESR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    EXTRESR::SYSRST => 0x02,
                    EXTRESR::POR => 0x03,
                    EXTRESR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> EXTRESR {
                match value {
                    2 => EXTRESR::SYSRST,
                    3 => EXTRESR::POR,
                    i => EXTRESR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSRST`"]
            #[inline]
            pub fn is_sysrst(&self) -> bool {
                *self == EXTRESR::SYSRST
            }
            #[doc = "Checks if the value of the field is `POR`"]
            #[inline]
            pub fn is_por(&self) -> bool {
                *self == EXTRESR::POR
            }
        }
        #[doc = "Possible values of the field `BOR`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum BORR {
            #[doc = "Brown Out Reset issues system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Brown Out Reset issues a simulated POR sequence. The application starts less than 500 us after deassertion (Default)"]
            POR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl BORR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    BORR::SYSRST => 0x02,
                    BORR::POR => 0x03,
                    BORR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> BORR {
                match value {
                    2 => BORR::SYSRST,
                    3 => BORR::POR,
                    i => BORR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSRST`"]
            #[inline]
            pub fn is_sysrst(&self) -> bool {
                *self == BORR::SYSRST
            }
            #[doc = "Checks if the value of the field is `POR`"]
            #[inline]
            pub fn is_por(&self) -> bool {
                *self == BORR::POR
            }
        }
        #[doc = "Possible values of the field `WDOG0`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WDOG0R {
            #[doc = "Watchdog 0 issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Watchdog 0 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl WDOG0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WDOG0R::SYSRST => 0x02,
                    WDOG0R::POR => 0x03,
                    WDOG0R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WDOG0R {
                match value {
                    2 => WDOG0R::SYSRST,
                    3 => WDOG0R::POR,
                    i => WDOG0R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSRST`"]
            #[inline]
            pub fn is_sysrst(&self) -> bool {
                *self == WDOG0R::SYSRST
            }
            #[doc = "Checks if the value of the field is `POR`"]
            #[inline]
            pub fn is_por(&self) -> bool {
                *self == WDOG0R::POR
            }
        }
        #[doc = "Possible values of the field `WDOG1`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum WDOG1R {
            #[doc = "Watchdog 1 issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Watchdog 1 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl WDOG1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    WDOG1R::SYSRST => 0x02,
                    WDOG1R::POR => 0x03,
                    WDOG1R::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> WDOG1R {
                match value {
                    2 => WDOG1R::SYSRST,
                    3 => WDOG1R::POR,
                    i => WDOG1R::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SYSRST`"]
            #[inline]
            pub fn is_sysrst(&self) -> bool {
                *self == WDOG1R::SYSRST
            }
            #[doc = "Checks if the value of the field is `POR`"]
            #[inline]
            pub fn is_por(&self) -> bool {
                *self == WDOG1R::POR
            }
        }
        #[doc = "Values that can be written to the field `EXTRES`"]
        pub enum EXTRESW {
            #[doc = "External RST assertion issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "External RST assertion issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
        }
        impl EXTRESW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    EXTRESW::SYSRST => 2,
                    EXTRESW::POR => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _EXTRESW<'a> {
            w: &'a mut W,
        }
        impl<'a> _EXTRESW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: EXTRESW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "External RST assertion issues a system reset. The application starts within 10 us"]
            #[inline]
            pub fn sysrst(self) -> &'a mut W {
                self.variant(EXTRESW::SYSRST)
            }
            #[doc = "External RST assertion issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            #[inline]
            pub fn por(self) -> &'a mut W {
                self.variant(EXTRESW::POR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `BOR`"]
        pub enum BORW {
            #[doc = "Brown Out Reset issues system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Brown Out Reset issues a simulated POR sequence. The application starts less than 500 us after deassertion (Default)"]
            POR,
        }
        impl BORW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    BORW::SYSRST => 2,
                    BORW::POR => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _BORW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BORW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: BORW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Brown Out Reset issues system reset. The application starts within 10 us"]
            #[inline]
            pub fn sysrst(self) -> &'a mut W {
                self.variant(BORW::SYSRST)
            }
            #[doc = "Brown Out Reset issues a simulated POR sequence. The application starts less than 500 us after deassertion (Default)"]
            #[inline]
            pub fn por(self) -> &'a mut W {
                self.variant(BORW::POR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WDOG0`"]
        pub enum WDOG0W {
            #[doc = "Watchdog 0 issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Watchdog 0 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
        }
        impl WDOG0W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WDOG0W::SYSRST => 2,
                    WDOG0W::POR => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDOG0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDOG0W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WDOG0W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Watchdog 0 issues a system reset. The application starts within 10 us"]
            #[inline]
            pub fn sysrst(self) -> &'a mut W {
                self.variant(WDOG0W::SYSRST)
            }
            #[doc = "Watchdog 0 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            #[inline]
            pub fn por(self) -> &'a mut W {
                self.variant(WDOG0W::POR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `WDOG1`"]
        pub enum WDOG1W {
            #[doc = "Watchdog 1 issues a system reset. The application starts within 10 us"]
            SYSRST,
            #[doc = "Watchdog 1 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            POR,
        }
        impl WDOG1W {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    WDOG1W::SYSRST => 2,
                    WDOG1W::POR => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _WDOG1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _WDOG1W<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: WDOG1W) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Watchdog 1 issues a system reset. The application starts within 10 us"]
            #[inline]
            pub fn sysrst(self) -> &'a mut W {
                self.variant(WDOG1W::SYSRST)
            }
            #[doc = "Watchdog 1 issues a simulated POR sequence. Application starts less than 500 us after deassertion (Default)"]
            #[inline]
            pub fn por(self) -> &'a mut W {
                self.variant(WDOG1W::POR)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - External RST Pin Operation"]
            #[inline]
            pub fn extres(&self) -> EXTRESR {
                EXTRESR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - BOR Reset operation"]
            #[inline]
            pub fn bor(&self) -> BORR {
                BORR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Watchdog 0 Reset Operation"]
            #[inline]
            pub fn wdog0(&self) -> WDOG0R {
                WDOG0R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 6:7 - Watchdog 1 Reset Operation"]
            #[inline]
            pub fn wdog1(&self) -> WDOG1R {
                WDOG1R::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - External RST Pin Operation"]
            #[inline]
            pub fn extres(&mut self) -> _EXTRESW {
                _EXTRESW { w: self }
            }
            #[doc = "Bits 2:3 - BOR Reset operation"]
            #[inline]
            pub fn bor(&mut self) -> _BORW {
                _BORW { w: self }
            }
            #[doc = "Bits 4:5 - Watchdog 0 Reset Operation"]
            #[inline]
            pub fn wdog0(&mut self) -> _WDOG0W {
                _WDOG0W { w: self }
            }
            #[doc = "Bits 6:7 - Watchdog 1 Reset Operation"]
            #[inline]
            pub fn wdog1(&mut self) -> _WDOG1W {
                _WDOG1W { w: self }
            }
        }
    }
    #[doc = "Hardware System Service Request"]
    pub struct HSSR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hardware System Service Request"]
    pub mod hssr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::HSSR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CDOFFR {
            bits: u32,
        }
        impl CDOFFR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct KEYR {
            bits: u8,
        }
        impl KEYR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CDOFFW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CDOFFW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x00ff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _KEYW<'a> {
            w: &'a mut W,
        }
        impl<'a> _KEYW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0xff;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:23 - Command Descriptor Pointer"]
            #[inline]
            pub fn cdoff(&self) -> CDOFFR {
                let bits = {
                    const MASK: u32 = 0x00ff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                CDOFFR { bits }
            }
            #[doc = "Bits 24:31 - Write Key"]
            #[inline]
            pub fn key(&self) -> KEYR {
                let bits = {
                    const MASK: u8 = 0xff;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                KEYR { bits }
            }
        }
        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 0:23 - Command Descriptor Pointer"]
            #[inline]
            pub fn cdoff(&mut self) -> _CDOFFW {
                _CDOFFW { w: self }
            }
            #[doc = "Bits 24:31 - Write Key"]
            #[inline]
            pub fn key(&mut self) -> _KEYW {
                _KEYW { w: self }
            }
        }
    }
    #[doc = "USB Power Domain Status"]
    pub struct USBPDS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Power Domain Status"]
    pub mod usbpds {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::USBPDS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `PWRSTAT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PWRSTATR {
            #[doc = "OFF"]
            OFF,
            #[doc = "ON"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PWRSTATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PWRSTATR::OFF => 0,
                    PWRSTATR::ON => 0x03,
                    PWRSTATR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PWRSTATR {
                match value {
                    0 => PWRSTATR::OFF,
                    3 => PWRSTATR::ON,
                    i => PWRSTATR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == PWRSTATR::OFF
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == PWRSTATR::ON
            }
        }
        #[doc = "Possible values of the field `MEMSTAT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MEMSTATR {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "SRAM Retention"]
            RETAIN,
            #[doc = "Array On"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MEMSTATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MEMSTATR::OFF => 0,
                    MEMSTATR::RETAIN => 0x01,
                    MEMSTATR::ON => 0x03,
                    MEMSTATR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MEMSTATR {
                match value {
                    0 => MEMSTATR::OFF,
                    1 => MEMSTATR::RETAIN,
                    3 => MEMSTATR::ON,
                    i => MEMSTATR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == MEMSTATR::OFF
            }
            #[doc = "Checks if the value of the field is `RETAIN`"]
            #[inline]
            pub fn is_retain(&self) -> bool {
                *self == MEMSTATR::RETAIN
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == MEMSTATR::ON
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Power Domain Status"]
            #[inline]
            pub fn pwrstat(&self) -> PWRSTATR {
                PWRSTATR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Memory Array Power Status"]
            #[inline]
            pub fn memstat(&self) -> MEMSTATR {
                MEMSTATR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
    }
    #[doc = "USB Memory Power Control"]
    pub struct USBMPC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "USB Memory Power Control"]
    pub mod usbmpc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USBMPC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PWRCTL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PWRCTLR {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "SRAM Retention"]
            RETAIN,
            #[doc = "Array On"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PWRCTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PWRCTLR::OFF => 0,
                    PWRCTLR::RETAIN => 0x01,
                    PWRCTLR::ON => 0x03,
                    PWRCTLR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PWRCTLR {
                match value {
                    0 => PWRCTLR::OFF,
                    1 => PWRCTLR::RETAIN,
                    3 => PWRCTLR::ON,
                    i => PWRCTLR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == PWRCTLR::OFF
            }
            #[doc = "Checks if the value of the field is `RETAIN`"]
            #[inline]
            pub fn is_retain(&self) -> bool {
                *self == PWRCTLR::RETAIN
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == PWRCTLR::ON
            }
        }
        #[doc = "Values that can be written to the field `PWRCTL`"]
        pub enum PWRCTLW {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "SRAM Retention"]
            RETAIN,
            #[doc = "Array On"]
            ON,
        }
        impl PWRCTLW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PWRCTLW::OFF => 0,
                    PWRCTLW::RETAIN => 1,
                    PWRCTLW::ON => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWRCTLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWRCTLW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PWRCTLW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Array OFF"]
            #[inline]
            pub fn off(self) -> &'a mut W {
                self.variant(PWRCTLW::OFF)
            }
            #[doc = "SRAM Retention"]
            #[inline]
            pub fn retain(self) -> &'a mut W {
                self.variant(PWRCTLW::RETAIN)
            }
            #[doc = "Array On"]
            #[inline]
            pub fn on(self) -> &'a mut W {
                self.variant(PWRCTLW::ON)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Memory Array Power Control"]
            #[inline]
            pub fn pwrctl(&self) -> PWRCTLR {
                PWRCTLR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Memory Array Power Control"]
            #[inline]
            pub fn pwrctl(&mut self) -> _PWRCTLW {
                _PWRCTLW { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Power Domain Status"]
    pub struct EMACPDS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Power Domain Status"]
    pub mod emacpds {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::EMACPDS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = "Possible values of the field `PWRSTAT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PWRSTATR {
            #[doc = "OFF"]
            OFF,
            #[doc = "ON"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PWRSTATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PWRSTATR::OFF => 0,
                    PWRSTATR::ON => 0x03,
                    PWRSTATR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PWRSTATR {
                match value {
                    0 => PWRSTATR::OFF,
                    3 => PWRSTATR::ON,
                    i => PWRSTATR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == PWRSTATR::OFF
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == PWRSTATR::ON
            }
        }
        #[doc = "Possible values of the field `MEMSTAT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum MEMSTATR {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "Array On"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl MEMSTATR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    MEMSTATR::OFF => 0,
                    MEMSTATR::ON => 0x03,
                    MEMSTATR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> MEMSTATR {
                match value {
                    0 => MEMSTATR::OFF,
                    3 => MEMSTATR::ON,
                    i => MEMSTATR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == MEMSTATR::OFF
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == MEMSTATR::ON
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Power Domain Status"]
            #[inline]
            pub fn pwrstat(&self) -> PWRSTATR {
                PWRSTATR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 2:3 - Memory Array Power Status"]
            #[inline]
            pub fn memstat(&self) -> MEMSTATR {
                MEMSTATR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
    }
    #[doc = "Ethernet MAC Memory Power Control"]
    pub struct EMACMPC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Memory Power Control"]
    pub mod emacmpc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::EMACMPC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `PWRCTL`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum PWRCTLR {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "Array On"]
            ON,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl PWRCTLR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    PWRCTLR::OFF => 0,
                    PWRCTLR::ON => 0x03,
                    PWRCTLR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> PWRCTLR {
                match value {
                    0 => PWRCTLR::OFF,
                    3 => PWRCTLR::ON,
                    i => PWRCTLR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `OFF`"]
            #[inline]
            pub fn is_off(&self) -> bool {
                *self == PWRCTLR::OFF
            }
            #[doc = "Checks if the value of the field is `ON`"]
            #[inline]
            pub fn is_on(&self) -> bool {
                *self == PWRCTLR::ON
            }
        }
        #[doc = "Values that can be written to the field `PWRCTL`"]
        pub enum PWRCTLW {
            #[doc = "Array OFF"]
            OFF,
            #[doc = "Array On"]
            ON,
        }
        impl PWRCTLW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    PWRCTLW::OFF => 0,
                    PWRCTLW::ON => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _PWRCTLW<'a> {
            w: &'a mut W,
        }
        impl<'a> _PWRCTLW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: PWRCTLW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Array OFF"]
            #[inline]
            pub fn off(self) -> &'a mut W {
                self.variant(PWRCTLW::OFF)
            }
            #[doc = "Array On"]
            #[inline]
            pub fn on(self) -> &'a mut W {
                self.variant(PWRCTLW::ON)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:1 - Memory Array Power Control"]
            #[inline]
            pub fn pwrctl(&self) -> PWRCTLR {
                PWRCTLR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:1 - Memory Array Power Control"]
            #[inline]
            pub fn pwrctl(&mut self) -> _PWRCTLW {
                _PWRCTLW { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Peripheral Present"]
    pub struct PPWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Peripheral Present"]
    pub mod ppwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPWD {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Peripheral Present"]
    pub struct PPTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Peripheral Present"]
    pub mod pptimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPTIMER {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Present"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Present"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Present"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Present"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Present"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Present"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Peripheral Present"]
    pub struct PPGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Peripheral Present"]
    pub mod ppgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPGPIO {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P8R {
            bits: bool,
        }
        impl P8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P9R {
            bits: bool,
        }
        impl P9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P10R {
            bits: bool,
        }
        impl P10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P11R {
            bits: bool,
        }
        impl P11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P12R {
            bits: bool,
        }
        impl P12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P13R {
            bits: bool,
        }
        impl P13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P14R {
            bits: bool,
        }
        impl P14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Present"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Present"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Present"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Present"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Present"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Present"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Present"]
            #[inline]
            pub fn p8(&self) -> P8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Present"]
            #[inline]
            pub fn p9(&self) -> P9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Present"]
            #[inline]
            pub fn p10(&self) -> P10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Present"]
            #[inline]
            pub fn p11(&self) -> P11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Present"]
            #[inline]
            pub fn p12(&self) -> P12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Present"]
            #[inline]
            pub fn p13(&self) -> P13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Present"]
            #[inline]
            pub fn p14(&self) -> P14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P14R { bits }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Peripheral Present"]
    pub struct PPDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Peripheral Present"]
    pub mod ppdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPDMA {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "EPI Peripheral Present"]
    pub struct PPEPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Peripheral Present"]
    pub mod ppepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPEPI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Hibernation Peripheral Present"]
    pub struct PPHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Peripheral Present"]
    pub mod pphib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPHIB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Peripheral Present"]
    pub struct PPUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Peripheral Present"]
    pub mod ppuart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPUART {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Present"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Present"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Present"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Present"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Present"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Present"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Peripheral Present"]
    pub struct PPSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Peripheral Present"]
    pub mod ppssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPSSI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Present"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Present"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Peripheral Present"]
    pub struct PPI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Peripheral Present"]
    pub mod ppi2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPI2C {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P8R {
            bits: bool,
        }
        impl P8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P9R {
            bits: bool,
        }
        impl P9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Present"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Present"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Present"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Present"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Present"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Present"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Present"]
            #[inline]
            pub fn p8(&self) -> P8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Present"]
            #[inline]
            pub fn p9(&self) -> P9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P9R { bits }
            }
        }
    }
    #[doc = "Universal Serial Bus Peripheral Present"]
    pub struct PPUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Peripheral Present"]
    pub mod ppusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPUSB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Ethernet PHY Peripheral Present"]
    pub struct PPEPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Peripheral Present"]
    pub mod ppephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPEPHY {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Controller Area Network Peripheral Present"]
    pub struct PPCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Peripheral Present"]
    pub mod ppcan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPCAN {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Peripheral Present"]
    pub struct PPADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Peripheral Present"]
    pub mod ppadc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPADC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Present"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
    }
    #[doc = "Analog Comparator Peripheral Present"]
    pub struct PPACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Peripheral Present"]
    pub mod ppacmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPACMP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Pulse Width Modulator Peripheral Present"]
    pub struct PPPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Peripheral Present"]
    pub mod pppwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPPWM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Peripheral Present"]
    pub struct PPQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Peripheral Present"]
    pub mod ppqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPQEI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Low Pin Count Interface Peripheral Present"]
    pub struct PPLPC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Low Pin Count Interface Peripheral Present"]
    pub mod pplpc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPLPC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - LPC Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Platform Environment Control Interface Peripheral Present"]
    pub struct PPPECI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Platform Environment Control Interface Peripheral Present"]
    pub mod pppeci {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPPECI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PECI Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Fan Control Peripheral Present"]
    pub struct PPFAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Fan Control Peripheral Present"]
    pub mod ppfan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPFAN {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - FAN Module 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "EEPROM Peripheral Present"]
    pub struct PPEEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Peripheral Present"]
    pub mod ppeeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPEEPROM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "32/64-Bit Wide General-Purpose Timer Peripheral Present"]
    pub struct PPWTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "32/64-Bit Wide General-Purpose Timer Peripheral Present"]
    pub mod ppwtimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPWTIMER {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 32/64-Bit Wide General-Purpose Timer 0 Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Remote Temperature Sensor Peripheral Present"]
    pub struct PPRTS {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Remote Temperature Sensor Peripheral Present"]
    pub mod pprts {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPRTS {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - RTS Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Peripheral Present"]
    pub struct PPCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Peripheral Present"]
    pub mod ppccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPCCM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "LCD Peripheral Present"]
    pub struct PPLCD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "LCD Peripheral Present"]
    pub mod pplcd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPLCD {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - LCD Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "1-Wire Peripheral Present"]
    pub struct PPOWIRE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "1-Wire Peripheral Present"]
    pub mod ppowire {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPOWIRE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 1-Wire Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Peripheral Present"]
    pub struct PPEMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Peripheral Present"]
    pub mod ppemac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPEMAC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet Controller Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Human Interface Master Peripheral Present"]
    pub struct PPHIM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Human Interface Master Peripheral Present"]
    pub mod pphim {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PPHIM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - HIM Module Present"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
    }
    #[doc = "Watchdog Timer Software Reset"]
    pub struct SRWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Software Reset"]
    pub mod srwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRWD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - Watchdog Timer 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Software Reset"]
    pub struct SRTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Software Reset"]
    pub mod srtimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRTIMER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Software Reset"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Software Reset"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Software Reset"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Software Reset"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Software Reset"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Software Reset"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
        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 = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Software Reset"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Software Reset"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Software Reset"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Software Reset"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Software Reset"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Software Reset"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Software Reset"]
    pub struct SRGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Software Reset"]
    pub mod srgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRGPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R10R {
            bits: bool,
        }
        impl R10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R11R {
            bits: bool,
        }
        impl R11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R12R {
            bits: bool,
        }
        impl R12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R13R {
            bits: bool,
        }
        impl R13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R14R {
            bits: bool,
        }
        impl R14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R10W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R10W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R11W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R11W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R12W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R13W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R13W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R14W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R14W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Software Reset"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Software Reset"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Software Reset"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Software Reset"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Software Reset"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Software Reset"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Software Reset"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Software Reset"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Software Reset"]
            #[inline]
            pub fn r10(&self) -> R10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Software Reset"]
            #[inline]
            pub fn r11(&self) -> R11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Software Reset"]
            #[inline]
            pub fn r12(&self) -> R12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Software Reset"]
            #[inline]
            pub fn r13(&self) -> R13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Software Reset"]
            #[inline]
            pub fn r14(&self) -> R14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R14R { bits }
            }
        }
        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 = "Bit 0 - GPIO Port A Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - GPIO Port B Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - GPIO Port C Software Reset"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - GPIO Port D Software Reset"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - GPIO Port E Software Reset"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - GPIO Port F Software Reset"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - GPIO Port G Software Reset"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - GPIO Port H Software Reset"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
            #[doc = "Bit 8 - GPIO Port J Software Reset"]
            #[inline]
            pub fn r8(&mut self) -> _R8W {
                _R8W { w: self }
            }
            #[doc = "Bit 9 - GPIO Port K Software Reset"]
            #[inline]
            pub fn r9(&mut self) -> _R9W {
                _R9W { w: self }
            }
            #[doc = "Bit 10 - GPIO Port L Software Reset"]
            #[inline]
            pub fn r10(&mut self) -> _R10W {
                _R10W { w: self }
            }
            #[doc = "Bit 11 - GPIO Port M Software Reset"]
            #[inline]
            pub fn r11(&mut self) -> _R11W {
                _R11W { w: self }
            }
            #[doc = "Bit 12 - GPIO Port N Software Reset"]
            #[inline]
            pub fn r12(&mut self) -> _R12W {
                _R12W { w: self }
            }
            #[doc = "Bit 13 - GPIO Port P Software Reset"]
            #[inline]
            pub fn r13(&mut self) -> _R13W {
                _R13W { w: self }
            }
            #[doc = "Bit 14 - GPIO Port Q Software Reset"]
            #[inline]
            pub fn r14(&mut self) -> _R14W {
                _R14W { w: self }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Software Reset"]
    pub struct SRDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Software Reset"]
    pub mod srdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRDMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - uDMA Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "EPI Software Reset"]
    pub struct SREPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Software Reset"]
    pub mod srepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SREPI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - EPI Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Hibernation Software Reset"]
    pub struct SRHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Software Reset"]
    pub mod srhib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRHIB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Hibernation Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Software Reset"]
    pub struct SRUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Software Reset"]
    pub mod sruart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRUART {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Software Reset"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Software Reset"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Software Reset"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Software Reset"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Software Reset"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Software Reset"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
        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 = "Bit 0 - UART Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - UART Module 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - UART Module 2 Software Reset"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - UART Module 3 Software Reset"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - UART Module 4 Software Reset"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - UART Module 5 Software Reset"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - UART Module 6 Software Reset"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - UART Module 7 Software Reset"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Software Reset"]
    pub struct SRSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Software Reset"]
    pub mod srssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Software Reset"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Software Reset"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
        }
        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 = "Bit 0 - SSI Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - SSI Module 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - SSI Module 2 Software Reset"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - SSI Module 3 Software Reset"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Software Reset"]
    pub struct SRI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Software Reset"]
    pub mod sri2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRI2C {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Software Reset"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Software Reset"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Software Reset"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Software Reset"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Software Reset"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Software Reset"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Software Reset"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Software Reset"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
        }
        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 = "Bit 0 - I2C Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - I2C Module 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - I2C Module 2 Software Reset"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - I2C Module 3 Software Reset"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - I2C Module 4 Software Reset"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - I2C Module 5 Software Reset"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - I2C Module 6 Software Reset"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - I2C Module 7 Software Reset"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
            #[doc = "Bit 8 - I2C Module 8 Software Reset"]
            #[inline]
            pub fn r8(&mut self) -> _R8W {
                _R8W { w: self }
            }
            #[doc = "Bit 9 - I2C Module 9 Software Reset"]
            #[inline]
            pub fn r9(&mut self) -> _R9W {
                _R9W { w: self }
            }
        }
    }
    #[doc = "Universal Serial Bus Software Reset"]
    pub struct SRUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Software Reset"]
    pub mod srusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRUSB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - USB Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Software Reset"]
    pub struct SREPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Software Reset"]
    pub mod srephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SREPHY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Controller Area Network Software Reset"]
    pub struct SRCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Software Reset"]
    pub mod srcan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRCAN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - CAN Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - CAN Module 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Software Reset"]
    pub struct SRADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Software Reset"]
    pub mod sradc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRADC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Software Reset"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - ADC Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - ADC Module 1 Software Reset"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Software Reset"]
    pub struct SRACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Software Reset"]
    pub mod sracmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRACMP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Analog Comparator Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Pulse Width Modulator Software Reset"]
    pub struct SRPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Software Reset"]
    pub mod srpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRPWM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - PWM Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Software Reset"]
    pub struct SRQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Software Reset"]
    pub mod srqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRQEI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - QEI Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "EEPROM Software Reset"]
    pub struct SREEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Software Reset"]
    pub mod sreeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SREEPROM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - EEPROM Module Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Software Reset"]
    pub struct SRCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Software Reset"]
    pub mod srccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SRCCM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - CRC and Cryptographic Modules Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Software Reset"]
    pub struct SREMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Software Reset"]
    pub mod sremac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SREMAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet Controller MAC Module 0 Software Reset"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet Controller MAC Module 0 Software Reset"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Run Mode Clock Gating Control"]
    pub struct RCGCWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Run Mode Clock Gating Control"]
    pub mod rcgcwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCWD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - Watchdog Timer 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Run Mode Clock Gating Control"]
    pub struct RCGCTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Run Mode Clock Gating Control"]
    pub mod rcgctimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCTIMER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
        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 = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Run Mode Clock Gating Control"]
    pub struct RCGCGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Run Mode Clock Gating Control"]
    pub mod rcgcgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCGPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R10R {
            bits: bool,
        }
        impl R10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R11R {
            bits: bool,
        }
        impl R11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R12R {
            bits: bool,
        }
        impl R12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R13R {
            bits: bool,
        }
        impl R13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R14R {
            bits: bool,
        }
        impl R14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R10W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R10W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R11W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R11W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R12W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R13W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R13W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R14W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R14W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Run Mode Clock Gating Control"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Run Mode Clock Gating Control"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Run Mode Clock Gating Control"]
            #[inline]
            pub fn r10(&self) -> R10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Run Mode Clock Gating Control"]
            #[inline]
            pub fn r11(&self) -> R11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Run Mode Clock Gating Control"]
            #[inline]
            pub fn r12(&self) -> R12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Run Mode Clock Gating Control"]
            #[inline]
            pub fn r13(&self) -> R13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Run Mode Clock Gating Control"]
            #[inline]
            pub fn r14(&self) -> R14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R14R { bits }
            }
        }
        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 = "Bit 0 - GPIO Port A Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - GPIO Port B Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - GPIO Port C Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - GPIO Port D Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - GPIO Port E Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - GPIO Port F Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - GPIO Port G Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - GPIO Port H Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
            #[doc = "Bit 8 - GPIO Port J Run Mode Clock Gating Control"]
            #[inline]
            pub fn r8(&mut self) -> _R8W {
                _R8W { w: self }
            }
            #[doc = "Bit 9 - GPIO Port K Run Mode Clock Gating Control"]
            #[inline]
            pub fn r9(&mut self) -> _R9W {
                _R9W { w: self }
            }
            #[doc = "Bit 10 - GPIO Port L Run Mode Clock Gating Control"]
            #[inline]
            pub fn r10(&mut self) -> _R10W {
                _R10W { w: self }
            }
            #[doc = "Bit 11 - GPIO Port M Run Mode Clock Gating Control"]
            #[inline]
            pub fn r11(&mut self) -> _R11W {
                _R11W { w: self }
            }
            #[doc = "Bit 12 - GPIO Port N Run Mode Clock Gating Control"]
            #[inline]
            pub fn r12(&mut self) -> _R12W {
                _R12W { w: self }
            }
            #[doc = "Bit 13 - GPIO Port P Run Mode Clock Gating Control"]
            #[inline]
            pub fn r13(&mut self) -> _R13W {
                _R13W { w: self }
            }
            #[doc = "Bit 14 - GPIO Port Q Run Mode Clock Gating Control"]
            #[inline]
            pub fn r14(&mut self) -> _R14W {
                _R14W { w: self }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Run Mode Clock Gating Control"]
    pub struct RCGCDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Run Mode Clock Gating Control"]
    pub mod rcgcdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCDMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - uDMA Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "EPI Run Mode Clock Gating Control"]
    pub struct RCGCEPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Run Mode Clock Gating Control"]
    pub mod rcgcepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCEPI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - EPI Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Hibernation Run Mode Clock Gating Control"]
    pub struct RCGCHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Run Mode Clock Gating Control"]
    pub mod rcgchib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCHIB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Hibernation Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Run Mode Clock Gating Control"]
    pub struct RCGCUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Run Mode Clock Gating Control"]
    pub mod rcgcuart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCUART {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
        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 = "Bit 0 - UART Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - UART Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - UART Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - UART Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - UART Module 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - UART Module 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - UART Module 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - UART Module 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Run Mode Clock Gating Control"]
    pub struct RCGCSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Run Mode Clock Gating Control"]
    pub mod rcgcssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
        }
        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 = "Bit 0 - SSI Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - SSI Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - SSI Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - SSI Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Run Mode Clock Gating Control"]
    pub struct RCGCI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Run Mode Clock Gating Control"]
    pub mod rcgci2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCI2C {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _R9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
        }
        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 = "Bit 0 - I2C Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - I2C Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
            #[doc = "Bit 2 - I2C Module 2 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r2(&mut self) -> _R2W {
                _R2W { w: self }
            }
            #[doc = "Bit 3 - I2C Module 3 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r3(&mut self) -> _R3W {
                _R3W { w: self }
            }
            #[doc = "Bit 4 - I2C Module 4 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r4(&mut self) -> _R4W {
                _R4W { w: self }
            }
            #[doc = "Bit 5 - I2C Module 5 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r5(&mut self) -> _R5W {
                _R5W { w: self }
            }
            #[doc = "Bit 6 - I2C Module 6 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r6(&mut self) -> _R6W {
                _R6W { w: self }
            }
            #[doc = "Bit 7 - I2C Module 7 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r7(&mut self) -> _R7W {
                _R7W { w: self }
            }
            #[doc = "Bit 8 - I2C Module 8 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r8(&mut self) -> _R8W {
                _R8W { w: self }
            }
            #[doc = "Bit 9 - I2C Module 9 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r9(&mut self) -> _R9W {
                _R9W { w: self }
            }
        }
    }
    #[doc = "Universal Serial Bus Run Mode Clock Gating Control"]
    pub struct RCGCUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Run Mode Clock Gating Control"]
    pub mod rcgcusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCUSB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - USB Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Run Mode Clock Gating Control"]
    pub struct RCGCEPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Run Mode Clock Gating Control"]
    pub mod rcgcephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCEPHY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Controller Area Network Run Mode Clock Gating Control"]
    pub struct RCGCCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Run Mode Clock Gating Control"]
    pub mod rcgccan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCCAN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - CAN Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - CAN Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Run Mode Clock Gating Control"]
    pub struct RCGCADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Run Mode Clock Gating Control"]
    pub mod rcgcadc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCADC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _R1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
        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 = "Bit 0 - ADC Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
            #[doc = "Bit 1 - ADC Module 1 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r1(&mut self) -> _R1W {
                _R1W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Run Mode Clock Gating Control"]
    pub struct RCGCACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Run Mode Clock Gating Control"]
    pub mod rcgcacmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCACMP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Analog Comparator Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Pulse Width Modulator Run Mode Clock Gating Control"]
    pub struct RCGCPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Run Mode Clock Gating Control"]
    pub mod rcgcpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCPWM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - PWM Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Run Mode Clock Gating Control"]
    pub struct RCGCQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Run Mode Clock Gating Control"]
    pub mod rcgcqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCQEI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - QEI Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "EEPROM Run Mode Clock Gating Control"]
    pub struct RCGCEEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Run Mode Clock Gating Control"]
    pub mod rcgceeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCEEPROM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - EEPROM Module Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Run Mode Clock Gating Control"]
    pub struct RCGCCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Run Mode Clock Gating Control"]
    pub mod rcgcccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCCCM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - CRC and Cryptographic Modules Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Run Mode Clock Gating Control"]
    pub struct RCGCEMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Run Mode Clock Gating Control"]
    pub mod rcgcemac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::RCGCEMAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _R0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _R0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet MAC Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet MAC Module 0 Run Mode Clock Gating Control"]
            #[inline]
            pub fn r0(&mut self) -> _R0W {
                _R0W { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Sleep Mode Clock Gating Control"]
    pub struct SCGCWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Sleep Mode Clock Gating Control"]
    pub mod scgcwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCWD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
        }
        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 = "Bit 0 - Watchdog Timer 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Sleep Mode Clock Gating Control"]
    pub struct SCGCTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Sleep Mode Clock Gating Control"]
    pub mod scgctimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCTIMER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2R {
            bits: bool,
        }
        impl S2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3R {
            bits: bool,
        }
        impl S3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4R {
            bits: bool,
        }
        impl S4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5R {
            bits: bool,
        }
        impl S5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6R {
            bits: bool,
        }
        impl S6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7R {
            bits: bool,
        }
        impl S7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&self) -> S2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&self) -> S3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&self) -> S4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&self) -> S5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&self) -> S6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&self) -> S7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S7R { bits }
            }
        }
        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 = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&mut self) -> _S2W {
                _S2W { w: self }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&mut self) -> _S3W {
                _S3W { w: self }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&mut self) -> _S4W {
                _S4W { w: self }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&mut self) -> _S5W {
                _S5W { w: self }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&mut self) -> _S6W {
                _S6W { w: self }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&mut self) -> _S7W {
                _S7W { w: self }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Sleep Mode Clock Gating Control"]
    pub struct SCGCGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Sleep Mode Clock Gating Control"]
    pub mod scgcgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCGPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2R {
            bits: bool,
        }
        impl S2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3R {
            bits: bool,
        }
        impl S3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4R {
            bits: bool,
        }
        impl S4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5R {
            bits: bool,
        }
        impl S5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6R {
            bits: bool,
        }
        impl S6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7R {
            bits: bool,
        }
        impl S7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S8R {
            bits: bool,
        }
        impl S8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S9R {
            bits: bool,
        }
        impl S9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S10R {
            bits: bool,
        }
        impl S10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S11R {
            bits: bool,
        }
        impl S11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S12R {
            bits: bool,
        }
        impl S12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S13R {
            bits: bool,
        }
        impl S13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S14R {
            bits: bool,
        }
        impl S14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S10W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S10W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S11W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S11W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S12W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S13W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S13W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S14W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S14W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&self) -> S2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&self) -> S3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&self) -> S4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&self) -> S5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&self) -> S6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&self) -> S7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s8(&self) -> S8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s9(&self) -> S9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s10(&self) -> S10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s11(&self) -> S11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s12(&self) -> S12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s13(&self) -> S13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s14(&self) -> S14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S14R { bits }
            }
        }
        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 = "Bit 0 - GPIO Port A Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - GPIO Port B Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
            #[doc = "Bit 2 - GPIO Port C Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&mut self) -> _S2W {
                _S2W { w: self }
            }
            #[doc = "Bit 3 - GPIO Port D Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&mut self) -> _S3W {
                _S3W { w: self }
            }
            #[doc = "Bit 4 - GPIO Port E Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&mut self) -> _S4W {
                _S4W { w: self }
            }
            #[doc = "Bit 5 - GPIO Port F Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&mut self) -> _S5W {
                _S5W { w: self }
            }
            #[doc = "Bit 6 - GPIO Port G Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&mut self) -> _S6W {
                _S6W { w: self }
            }
            #[doc = "Bit 7 - GPIO Port H Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&mut self) -> _S7W {
                _S7W { w: self }
            }
            #[doc = "Bit 8 - GPIO Port J Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s8(&mut self) -> _S8W {
                _S8W { w: self }
            }
            #[doc = "Bit 9 - GPIO Port K Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s9(&mut self) -> _S9W {
                _S9W { w: self }
            }
            #[doc = "Bit 10 - GPIO Port L Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s10(&mut self) -> _S10W {
                _S10W { w: self }
            }
            #[doc = "Bit 11 - GPIO Port M Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s11(&mut self) -> _S11W {
                _S11W { w: self }
            }
            #[doc = "Bit 12 - GPIO Port N Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s12(&mut self) -> _S12W {
                _S12W { w: self }
            }
            #[doc = "Bit 13 - GPIO Port P Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s13(&mut self) -> _S13W {
                _S13W { w: self }
            }
            #[doc = "Bit 14 - GPIO Port Q Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s14(&mut self) -> _S14W {
                _S14W { w: self }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Sleep Mode Clock Gating Control"]
    pub struct SCGCDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Sleep Mode Clock Gating Control"]
    pub mod scgcdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCDMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - uDMA Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "EPI Sleep Mode Clock Gating Control"]
    pub struct SCGCEPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Sleep Mode Clock Gating Control"]
    pub mod scgcepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCEPI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - EPI Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Hibernation Sleep Mode Clock Gating Control"]
    pub struct SCGCHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Sleep Mode Clock Gating Control"]
    pub mod scgchib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCHIB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - Hibernation Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Sleep Mode Clock Gating Control"]
    pub struct SCGCUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Sleep Mode Clock Gating Control"]
    pub mod scgcuart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCUART {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2R {
            bits: bool,
        }
        impl S2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3R {
            bits: bool,
        }
        impl S3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4R {
            bits: bool,
        }
        impl S4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5R {
            bits: bool,
        }
        impl S5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6R {
            bits: bool,
        }
        impl S6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7R {
            bits: bool,
        }
        impl S7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&self) -> S2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&self) -> S3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&self) -> S4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&self) -> S5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&self) -> S6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&self) -> S7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S7R { bits }
            }
        }
        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 = "Bit 0 - UART Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - UART Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
            #[doc = "Bit 2 - UART Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&mut self) -> _S2W {
                _S2W { w: self }
            }
            #[doc = "Bit 3 - UART Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&mut self) -> _S3W {
                _S3W { w: self }
            }
            #[doc = "Bit 4 - UART Module 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&mut self) -> _S4W {
                _S4W { w: self }
            }
            #[doc = "Bit 5 - UART Module 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&mut self) -> _S5W {
                _S5W { w: self }
            }
            #[doc = "Bit 6 - UART Module 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&mut self) -> _S6W {
                _S6W { w: self }
            }
            #[doc = "Bit 7 - UART Module 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&mut self) -> _S7W {
                _S7W { w: self }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Sleep Mode Clock Gating Control"]
    pub struct SCGCSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Sleep Mode Clock Gating Control"]
    pub mod scgcssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2R {
            bits: bool,
        }
        impl S2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3R {
            bits: bool,
        }
        impl S3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&self) -> S2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&self) -> S3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3R { bits }
            }
        }
        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 = "Bit 0 - SSI Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - SSI Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
            #[doc = "Bit 2 - SSI Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&mut self) -> _S2W {
                _S2W { w: self }
            }
            #[doc = "Bit 3 - SSI Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&mut self) -> _S3W {
                _S3W { w: self }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Sleep Mode Clock Gating Control"]
    pub struct SCGCI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Sleep Mode Clock Gating Control"]
    pub mod scgci2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCI2C {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S2R {
            bits: bool,
        }
        impl S2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S3R {
            bits: bool,
        }
        impl S3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S4R {
            bits: bool,
        }
        impl S4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S5R {
            bits: bool,
        }
        impl S5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S6R {
            bits: bool,
        }
        impl S6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S7R {
            bits: bool,
        }
        impl S7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S8R {
            bits: bool,
        }
        impl S8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S9R {
            bits: bool,
        }
        impl S9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _S9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&self) -> S2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&self) -> S3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&self) -> S4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&self) -> S5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&self) -> S6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&self) -> S7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s8(&self) -> S8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s9(&self) -> S9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S9R { bits }
            }
        }
        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 = "Bit 0 - I2C Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - I2C Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
            #[doc = "Bit 2 - I2C Module 2 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s2(&mut self) -> _S2W {
                _S2W { w: self }
            }
            #[doc = "Bit 3 - I2C Module 3 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s3(&mut self) -> _S3W {
                _S3W { w: self }
            }
            #[doc = "Bit 4 - I2C Module 4 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s4(&mut self) -> _S4W {
                _S4W { w: self }
            }
            #[doc = "Bit 5 - I2C Module 5 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s5(&mut self) -> _S5W {
                _S5W { w: self }
            }
            #[doc = "Bit 6 - I2C Module 6 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s6(&mut self) -> _S6W {
                _S6W { w: self }
            }
            #[doc = "Bit 7 - I2C Module 7 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s7(&mut self) -> _S7W {
                _S7W { w: self }
            }
            #[doc = "Bit 8 - I2C Module 8 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s8(&mut self) -> _S8W {
                _S8W { w: self }
            }
            #[doc = "Bit 9 - I2C Module 9 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s9(&mut self) -> _S9W {
                _S9W { w: self }
            }
        }
    }
    #[doc = "Universal Serial Bus Sleep Mode Clock Gating Control"]
    pub struct SCGCUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Sleep Mode Clock Gating Control"]
    pub mod scgcusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCUSB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - USB Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Sleep Mode Clock Gating Control"]
    pub struct SCGCEPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Sleep Mode Clock Gating Control"]
    pub mod scgcephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCEPHY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PHY Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - PHY Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Controller Area Network Sleep Mode Clock Gating Control"]
    pub struct SCGCCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Sleep Mode Clock Gating Control"]
    pub mod scgccan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCCAN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
        }
        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 = "Bit 0 - CAN Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - CAN Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Sleep Mode Clock Gating Control"]
    pub struct SCGCADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Sleep Mode Clock Gating Control"]
    pub mod scgcadc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCADC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct S1R {
            bits: bool,
        }
        impl S1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _S1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&self) -> S1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S1R { bits }
            }
        }
        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 = "Bit 0 - ADC Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
            #[doc = "Bit 1 - ADC Module 1 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s1(&mut self) -> _S1W {
                _S1W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Sleep Mode Clock Gating Control"]
    pub struct SCGCACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Sleep Mode Clock Gating Control"]
    pub mod scgcacmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCACMP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - Analog Comparator Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Pulse Width Modulator Sleep Mode Clock Gating Control"]
    pub struct SCGCPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Sleep Mode Clock Gating Control"]
    pub mod scgcpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCPWM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - PWM Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Sleep Mode Clock Gating Control"]
    pub struct SCGCQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Sleep Mode Clock Gating Control"]
    pub mod scgcqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCQEI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - QEI Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "EEPROM Sleep Mode Clock Gating Control"]
    pub struct SCGCEEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Sleep Mode Clock Gating Control"]
    pub mod scgceeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCEEPROM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - EEPROM Module Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Sleep Mode Clock Gating Control"]
    pub struct SCGCCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Sleep Mode Clock Gating Control"]
    pub mod scgcccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCCCM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - CRC and Cryptographic Modules Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Sleep Mode Clock Gating Control"]
    pub struct SCGCEMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Sleep Mode Clock Gating Control"]
    pub mod scgcemac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SCGCEMAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct S0R {
            bits: bool,
        }
        impl S0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _S0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _S0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet MAC Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&self) -> S0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                S0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet MAC Module 0 Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn s0(&mut self) -> _S0W {
                _S0W { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCWD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
        }
        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 = "Bit 0 - Watchdog Timer 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgctimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCTIMER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D4R {
            bits: bool,
        }
        impl D4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D5R {
            bits: bool,
        }
        impl D5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D6R {
            bits: bool,
        }
        impl D6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D7R {
            bits: bool,
        }
        impl D7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&self) -> D4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&self) -> D5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&self) -> D6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&self) -> D7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D7R { bits }
            }
        }
        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 = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&mut self) -> _D4W {
                _D4W { w: self }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&mut self) -> _D5W {
                _D5W { w: self }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&mut self) -> _D6W {
                _D6W { w: self }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&mut self) -> _D7W {
                _D7W { w: self }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCGPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D4R {
            bits: bool,
        }
        impl D4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D5R {
            bits: bool,
        }
        impl D5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D6R {
            bits: bool,
        }
        impl D6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D7R {
            bits: bool,
        }
        impl D7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D8R {
            bits: bool,
        }
        impl D8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D9R {
            bits: bool,
        }
        impl D9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D10R {
            bits: bool,
        }
        impl D10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D11R {
            bits: bool,
        }
        impl D11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D12R {
            bits: bool,
        }
        impl D12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D13R {
            bits: bool,
        }
        impl D13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D14R {
            bits: bool,
        }
        impl D14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D10W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D10W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D11W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D11W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D12W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D13W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D13W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D14W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D14W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&self) -> D4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&self) -> D5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&self) -> D6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&self) -> D7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d8(&self) -> D8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d9(&self) -> D9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d10(&self) -> D10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d11(&self) -> D11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d12(&self) -> D12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d13(&self) -> D13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d14(&self) -> D14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D14R { bits }
            }
        }
        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 = "Bit 0 - GPIO Port A Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - GPIO Port B Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 2 - GPIO Port C Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 3 - GPIO Port D Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 4 - GPIO Port E Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&mut self) -> _D4W {
                _D4W { w: self }
            }
            #[doc = "Bit 5 - GPIO Port F Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&mut self) -> _D5W {
                _D5W { w: self }
            }
            #[doc = "Bit 6 - GPIO Port G Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&mut self) -> _D6W {
                _D6W { w: self }
            }
            #[doc = "Bit 7 - GPIO Port H Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&mut self) -> _D7W {
                _D7W { w: self }
            }
            #[doc = "Bit 8 - GPIO Port J Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d8(&mut self) -> _D8W {
                _D8W { w: self }
            }
            #[doc = "Bit 9 - GPIO Port K Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d9(&mut self) -> _D9W {
                _D9W { w: self }
            }
            #[doc = "Bit 10 - GPIO Port L Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d10(&mut self) -> _D10W {
                _D10W { w: self }
            }
            #[doc = "Bit 11 - GPIO Port M Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d11(&mut self) -> _D11W {
                _D11W { w: self }
            }
            #[doc = "Bit 12 - GPIO Port N Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d12(&mut self) -> _D12W {
                _D12W { w: self }
            }
            #[doc = "Bit 13 - GPIO Port P Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d13(&mut self) -> _D13W {
                _D13W { w: self }
            }
            #[doc = "Bit 14 - GPIO Port Q Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d14(&mut self) -> _D14W {
                _D14W { w: self }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCDMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - uDMA Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "EPI Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCEPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCEPI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - EPI Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Hibernation Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgchib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCHIB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - Hibernation Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcuart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCUART {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D4R {
            bits: bool,
        }
        impl D4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D5R {
            bits: bool,
        }
        impl D5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D6R {
            bits: bool,
        }
        impl D6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D7R {
            bits: bool,
        }
        impl D7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&self) -> D4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&self) -> D5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&self) -> D6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&self) -> D7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D7R { bits }
            }
        }
        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 = "Bit 0 - UART Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - UART Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 2 - UART Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 3 - UART Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 4 - UART Module 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&mut self) -> _D4W {
                _D4W { w: self }
            }
            #[doc = "Bit 5 - UART Module 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&mut self) -> _D5W {
                _D5W { w: self }
            }
            #[doc = "Bit 6 - UART Module 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&mut self) -> _D6W {
                _D6W { w: self }
            }
            #[doc = "Bit 7 - UART Module 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&mut self) -> _D7W {
                _D7W { w: self }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
        }
        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 = "Bit 0 - SSI Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - SSI Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 2 - SSI Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 3 - SSI Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgci2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCI2C {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D2R {
            bits: bool,
        }
        impl D2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D3R {
            bits: bool,
        }
        impl D3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D4R {
            bits: bool,
        }
        impl D4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D5R {
            bits: bool,
        }
        impl D5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D6R {
            bits: bool,
        }
        impl D6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D7R {
            bits: bool,
        }
        impl D7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D8R {
            bits: bool,
        }
        impl D8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D9R {
            bits: bool,
        }
        impl D9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _D9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&self) -> D2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&self) -> D3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&self) -> D4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&self) -> D5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&self) -> D6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&self) -> D7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d8(&self) -> D8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d9(&self) -> D9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D9R { bits }
            }
        }
        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 = "Bit 0 - I2C Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - I2C Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
            #[doc = "Bit 2 - I2C Module 2 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d2(&mut self) -> _D2W {
                _D2W { w: self }
            }
            #[doc = "Bit 3 - I2C Module 3 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d3(&mut self) -> _D3W {
                _D3W { w: self }
            }
            #[doc = "Bit 4 - I2C Module 4 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d4(&mut self) -> _D4W {
                _D4W { w: self }
            }
            #[doc = "Bit 5 - I2C Module 5 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d5(&mut self) -> _D5W {
                _D5W { w: self }
            }
            #[doc = "Bit 6 - I2C Module 6 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d6(&mut self) -> _D6W {
                _D6W { w: self }
            }
            #[doc = "Bit 7 - I2C Module 7 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d7(&mut self) -> _D7W {
                _D7W { w: self }
            }
            #[doc = "Bit 8 - I2C Module 8 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d8(&mut self) -> _D8W {
                _D8W { w: self }
            }
            #[doc = "Bit 9 - I2C Module 9 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d9(&mut self) -> _D9W {
                _D9W { w: self }
            }
        }
    }
    #[doc = "Universal Serial Bus Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCUSB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - USB Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCEPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCEPHY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PHY Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - PHY Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Controller Area Network Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgccan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCCAN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
        }
        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 = "Bit 0 - CAN Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - CAN Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcadc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCADC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct D1R {
            bits: bool,
        }
        impl D1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _D1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&self) -> D1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D1R { bits }
            }
        }
        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 = "Bit 0 - ADC Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
            #[doc = "Bit 1 - ADC Module 1 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d1(&mut self) -> _D1W {
                _D1W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcacmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCACMP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - Analog Comparator Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Pulse Width Modulator Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCPWM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - PWM Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCQEI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - QEI Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "EEPROM Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCEEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgceeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCEEPROM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - EEPROM Module Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCCCM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - CRC and Cryptographic Modules Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Deep-Sleep Mode Clock Gating Control"]
    pub struct DCGCEMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Deep-Sleep Mode Clock Gating Control"]
    pub mod dcgcemac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::DCGCEMAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct D0R {
            bits: bool,
        }
        impl D0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _D0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _D0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet MAC Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&self) -> D0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                D0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet MAC Module 0 Deep-Sleep Mode Clock Gating Control"]
            #[inline]
            pub fn d0(&mut self) -> _D0W {
                _D0W { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Power Control"]
    pub struct PCWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Power Control"]
    pub mod pcwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCWD {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
        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 = "Bit 0 - Watchdog Timer 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Power Control"]
    pub struct PCTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Power Control"]
    pub mod pctimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCTIMER {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - General-Purpose Timer 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - General-Purpose Timer 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - General-Purpose Timer 2 Power Control"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - General-Purpose Timer 3 Power Control"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - General-Purpose Timer 4 Power Control"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - General-Purpose Timer 5 Power Control"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - General-Purpose Timer 6 Power Control"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - General-Purpose Timer 7 Power Control"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
        }
        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 = "Bit 0 - General-Purpose Timer 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - General-Purpose Timer 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
            #[doc = "Bit 2 - General-Purpose Timer 2 Power Control"]
            #[inline]
            pub fn p2(&mut self) -> _P2W {
                _P2W { w: self }
            }
            #[doc = "Bit 3 - General-Purpose Timer 3 Power Control"]
            #[inline]
            pub fn p3(&mut self) -> _P3W {
                _P3W { w: self }
            }
            #[doc = "Bit 4 - General-Purpose Timer 4 Power Control"]
            #[inline]
            pub fn p4(&mut self) -> _P4W {
                _P4W { w: self }
            }
            #[doc = "Bit 5 - General-Purpose Timer 5 Power Control"]
            #[inline]
            pub fn p5(&mut self) -> _P5W {
                _P5W { w: self }
            }
            #[doc = "Bit 6 - General-Purpose Timer 6 Power Control"]
            #[inline]
            pub fn p6(&mut self) -> _P6W {
                _P6W { w: self }
            }
            #[doc = "Bit 7 - General-Purpose Timer 7 Power Control"]
            #[inline]
            pub fn p7(&mut self) -> _P7W {
                _P7W { w: self }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Power Control"]
    pub struct PCGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Power Control"]
    pub mod pcgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCGPIO {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P8R {
            bits: bool,
        }
        impl P8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P9R {
            bits: bool,
        }
        impl P9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P10R {
            bits: bool,
        }
        impl P10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P11R {
            bits: bool,
        }
        impl P11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P12R {
            bits: bool,
        }
        impl P12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P13R {
            bits: bool,
        }
        impl P13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P14R {
            bits: bool,
        }
        impl P14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P10W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P10W<'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 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P11W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P11W<'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 = 11;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P12W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P12W<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P13W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P13W<'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 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P14W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P14W<'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 = 14;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Power Control"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Power Control"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Power Control"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Power Control"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Power Control"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Power Control"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Power Control"]
            #[inline]
            pub fn p8(&self) -> P8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Power Control"]
            #[inline]
            pub fn p9(&self) -> P9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Power Control"]
            #[inline]
            pub fn p10(&self) -> P10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Power Control"]
            #[inline]
            pub fn p11(&self) -> P11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Power Control"]
            #[inline]
            pub fn p12(&self) -> P12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Power Control"]
            #[inline]
            pub fn p13(&self) -> P13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Power Control"]
            #[inline]
            pub fn p14(&self) -> P14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P14R { bits }
            }
        }
        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 = "Bit 0 - GPIO Port A Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - GPIO Port B Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
            #[doc = "Bit 2 - GPIO Port C Power Control"]
            #[inline]
            pub fn p2(&mut self) -> _P2W {
                _P2W { w: self }
            }
            #[doc = "Bit 3 - GPIO Port D Power Control"]
            #[inline]
            pub fn p3(&mut self) -> _P3W {
                _P3W { w: self }
            }
            #[doc = "Bit 4 - GPIO Port E Power Control"]
            #[inline]
            pub fn p4(&mut self) -> _P4W {
                _P4W { w: self }
            }
            #[doc = "Bit 5 - GPIO Port F Power Control"]
            #[inline]
            pub fn p5(&mut self) -> _P5W {
                _P5W { w: self }
            }
            #[doc = "Bit 6 - GPIO Port G Power Control"]
            #[inline]
            pub fn p6(&mut self) -> _P6W {
                _P6W { w: self }
            }
            #[doc = "Bit 7 - GPIO Port H Power Control"]
            #[inline]
            pub fn p7(&mut self) -> _P7W {
                _P7W { w: self }
            }
            #[doc = "Bit 8 - GPIO Port J Power Control"]
            #[inline]
            pub fn p8(&mut self) -> _P8W {
                _P8W { w: self }
            }
            #[doc = "Bit 9 - GPIO Port K Power Control"]
            #[inline]
            pub fn p9(&mut self) -> _P9W {
                _P9W { w: self }
            }
            #[doc = "Bit 10 - GPIO Port L Power Control"]
            #[inline]
            pub fn p10(&mut self) -> _P10W {
                _P10W { w: self }
            }
            #[doc = "Bit 11 - GPIO Port M Power Control"]
            #[inline]
            pub fn p11(&mut self) -> _P11W {
                _P11W { w: self }
            }
            #[doc = "Bit 12 - GPIO Port N Power Control"]
            #[inline]
            pub fn p12(&mut self) -> _P12W {
                _P12W { w: self }
            }
            #[doc = "Bit 13 - GPIO Port P Power Control"]
            #[inline]
            pub fn p13(&mut self) -> _P13W {
                _P13W { w: self }
            }
            #[doc = "Bit 14 - GPIO Port Q Power Control"]
            #[inline]
            pub fn p14(&mut self) -> _P14W {
                _P14W { w: self }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Power Control"]
    pub struct PCDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Power Control"]
    pub mod pcdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCDMA {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - uDMA Module Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "External Peripheral Interface Power Control"]
    pub struct PCEPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "External Peripheral Interface Power Control"]
    pub mod pcepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCEPI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - EPI Module Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Hibernation Power Control"]
    pub struct PCHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Power Control"]
    pub mod pchib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCHIB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - Hibernation Module Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Power Control"]
    pub struct PCUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Power Control"]
    pub mod pcuart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCUART {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Power Control"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Power Control"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Power Control"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Power Control"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Power Control"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Power Control"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
        }
        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 = "Bit 0 - UART Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - UART Module 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
            #[doc = "Bit 2 - UART Module 2 Power Control"]
            #[inline]
            pub fn p2(&mut self) -> _P2W {
                _P2W { w: self }
            }
            #[doc = "Bit 3 - UART Module 3 Power Control"]
            #[inline]
            pub fn p3(&mut self) -> _P3W {
                _P3W { w: self }
            }
            #[doc = "Bit 4 - UART Module 4 Power Control"]
            #[inline]
            pub fn p4(&mut self) -> _P4W {
                _P4W { w: self }
            }
            #[doc = "Bit 5 - UART Module 5 Power Control"]
            #[inline]
            pub fn p5(&mut self) -> _P5W {
                _P5W { w: self }
            }
            #[doc = "Bit 6 - UART Module 6 Power Control"]
            #[inline]
            pub fn p6(&mut self) -> _P6W {
                _P6W { w: self }
            }
            #[doc = "Bit 7 - UART Module 7 Power Control"]
            #[inline]
            pub fn p7(&mut self) -> _P7W {
                _P7W { w: self }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Power Control"]
    pub struct PCSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Power Control"]
    pub mod pcssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCSSI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Power Control"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Power Control"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
        }
        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 = "Bit 0 - SSI Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - SSI Module 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
            #[doc = "Bit 2 - SSI Module 2 Power Control"]
            #[inline]
            pub fn p2(&mut self) -> _P2W {
                _P2W { w: self }
            }
            #[doc = "Bit 3 - SSI Module 3 Power Control"]
            #[inline]
            pub fn p3(&mut self) -> _P3W {
                _P3W { w: self }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Power Control"]
    pub struct PCI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Power Control"]
    pub mod pci2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCI2C {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P2R {
            bits: bool,
        }
        impl P2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P3R {
            bits: bool,
        }
        impl P3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P4R {
            bits: bool,
        }
        impl P4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P5R {
            bits: bool,
        }
        impl P5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P6R {
            bits: bool,
        }
        impl P6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P7R {
            bits: bool,
        }
        impl P7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P8R {
            bits: bool,
        }
        impl P8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P9R {
            bits: bool,
        }
        impl P9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P2W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P2W<'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 = 2;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P3W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P3W<'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 = 3;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P4W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P4W<'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 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P5W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P5W<'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 = 5;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P6W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P6W<'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 = 6;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P7W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P7W<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P8W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P8W<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _P9W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P9W<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Power Control"]
            #[inline]
            pub fn p2(&self) -> P2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Power Control"]
            #[inline]
            pub fn p3(&self) -> P3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Power Control"]
            #[inline]
            pub fn p4(&self) -> P4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Power Control"]
            #[inline]
            pub fn p5(&self) -> P5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Power Control"]
            #[inline]
            pub fn p6(&self) -> P6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Power Control"]
            #[inline]
            pub fn p7(&self) -> P7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Power Control"]
            #[inline]
            pub fn p8(&self) -> P8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Power Control"]
            #[inline]
            pub fn p9(&self) -> P9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P9R { bits }
            }
        }
        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 = "Bit 0 - I2C Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - I2C Module 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
            #[doc = "Bit 2 - I2C Module 2 Power Control"]
            #[inline]
            pub fn p2(&mut self) -> _P2W {
                _P2W { w: self }
            }
            #[doc = "Bit 3 - I2C Module 3 Power Control"]
            #[inline]
            pub fn p3(&mut self) -> _P3W {
                _P3W { w: self }
            }
            #[doc = "Bit 4 - I2C Module 4 Power Control"]
            #[inline]
            pub fn p4(&mut self) -> _P4W {
                _P4W { w: self }
            }
            #[doc = "Bit 5 - I2C Module 5 Power Control"]
            #[inline]
            pub fn p5(&mut self) -> _P5W {
                _P5W { w: self }
            }
            #[doc = "Bit 6 - I2C Module 6 Power Control"]
            #[inline]
            pub fn p6(&mut self) -> _P6W {
                _P6W { w: self }
            }
            #[doc = "Bit 7 - I2C Module 7 Power Control"]
            #[inline]
            pub fn p7(&mut self) -> _P7W {
                _P7W { w: self }
            }
            #[doc = "Bit 8 - I2C Module 8 Power Control"]
            #[inline]
            pub fn p8(&mut self) -> _P8W {
                _P8W { w: self }
            }
            #[doc = "Bit 9 - I2C Module 9 Power Control"]
            #[inline]
            pub fn p9(&mut self) -> _P9W {
                _P9W { w: self }
            }
        }
    }
    #[doc = "Universal Serial Bus Power Control"]
    pub struct PCUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Power Control"]
    pub mod pcusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCUSB {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - USB Module Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Ethernet PHY Power Control"]
    pub struct PCEPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Power Control"]
    pub mod pcephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCEPHY {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Module Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet PHY Module Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Controller Area Network Power Control"]
    pub struct PCCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Power Control"]
    pub mod pccan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCCAN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
        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 = "Bit 0 - CAN Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - CAN Module 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Power Control"]
    pub struct PCADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Power Control"]
    pub mod pcadc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCADC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct P1R {
            bits: bool,
        }
        impl P1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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
            }
        }
        #[doc = r" Proxy"]
        pub struct _P1W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P1W<'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 = 1;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Power Control"]
            #[inline]
            pub fn p1(&self) -> P1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P1R { bits }
            }
        }
        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 = "Bit 0 - ADC Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
            #[doc = "Bit 1 - ADC Module 1 Power Control"]
            #[inline]
            pub fn p1(&mut self) -> _P1W {
                _P1W { w: self }
            }
        }
    }
    #[doc = "Analog Comparator Power Control"]
    pub struct PCACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Power Control"]
    pub mod pcacmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCACMP {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - Analog Comparator Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Pulse Width Modulator Power Control"]
    pub struct PCPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Power Control"]
    pub mod pcpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCPWM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - PWM Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Power Control"]
    pub struct PCQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Power Control"]
    pub mod pcqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCQEI {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - QEI Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "EEPROM Power Control"]
    pub struct PCEEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Power Control"]
    pub mod pceeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCEEPROM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - EEPROM Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Power Control"]
    pub struct PCCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Power Control"]
    pub mod pcccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCCCM {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - CRC and Cryptographic Modules Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Ethernet MAC Power Control"]
    pub struct PCEMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Power Control"]
    pub mod pcemac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PCEMAC {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct P0R {
            bits: bool,
        }
        impl P0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _P0W<'a> {
            w: &'a mut W,
        }
        impl<'a> _P0W<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet MAC Module 0 Power Control"]
            #[inline]
            pub fn p0(&self) -> P0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                P0R { bits }
            }
        }
        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 = "Bit 0 - Ethernet MAC Module 0 Power Control"]
            #[inline]
            pub fn p0(&mut self) -> _P0W {
                _P0W { w: self }
            }
        }
    }
    #[doc = "Watchdog Timer Peripheral Ready"]
    pub struct PRWD {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Watchdog Timer Peripheral Ready"]
    pub mod prwd {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRWD {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Watchdog Timer 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - Watchdog Timer 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
    }
    #[doc = "16/32-Bit General-Purpose Timer Peripheral Ready"]
    pub struct PRTIMER {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "16/32-Bit General-Purpose Timer Peripheral Ready"]
    pub mod prtimer {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRTIMER {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - 16/32-Bit General-Purpose Timer 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - 16/32-Bit General-Purpose Timer 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - 16/32-Bit General-Purpose Timer 2 Peripheral Ready"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - 16/32-Bit General-Purpose Timer 3 Peripheral Ready"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - 16/32-Bit General-Purpose Timer 4 Peripheral Ready"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - 16/32-Bit General-Purpose Timer 5 Peripheral Ready"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - 16/32-Bit General-Purpose Timer 6 Peripheral Ready"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - 16/32-Bit General-Purpose Timer 7 Peripheral Ready"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
    }
    #[doc = "General-Purpose Input/Output Peripheral Ready"]
    pub struct PRGPIO {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "General-Purpose Input/Output Peripheral Ready"]
    pub mod prgpio {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRGPIO {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R10R {
            bits: bool,
        }
        impl R10R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R11R {
            bits: bool,
        }
        impl R11R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R12R {
            bits: bool,
        }
        impl R12R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R13R {
            bits: bool,
        }
        impl R13R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R14R {
            bits: bool,
        }
        impl R14R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - GPIO Port A Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - GPIO Port B Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - GPIO Port C Peripheral Ready"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - GPIO Port D Peripheral Ready"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - GPIO Port E Peripheral Ready"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - GPIO Port F Peripheral Ready"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - GPIO Port G Peripheral Ready"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - GPIO Port H Peripheral Ready"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - GPIO Port J Peripheral Ready"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - GPIO Port K Peripheral Ready"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
            #[doc = "Bit 10 - GPIO Port L Peripheral Ready"]
            #[inline]
            pub fn r10(&self) -> R10R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R10R { bits }
            }
            #[doc = "Bit 11 - GPIO Port M Peripheral Ready"]
            #[inline]
            pub fn r11(&self) -> R11R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 11;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R11R { bits }
            }
            #[doc = "Bit 12 - GPIO Port N Peripheral Ready"]
            #[inline]
            pub fn r12(&self) -> R12R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R12R { bits }
            }
            #[doc = "Bit 13 - GPIO Port P Peripheral Ready"]
            #[inline]
            pub fn r13(&self) -> R13R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R13R { bits }
            }
            #[doc = "Bit 14 - GPIO Port Q Peripheral Ready"]
            #[inline]
            pub fn r14(&self) -> R14R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 14;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R14R { bits }
            }
        }
    }
    #[doc = "Micro Direct Memory Access Peripheral Ready"]
    pub struct PRDMA {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Micro Direct Memory Access Peripheral Ready"]
    pub mod prdma {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRDMA {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "EPI Peripheral Ready"]
    pub struct PREPI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EPI Peripheral Ready"]
    pub mod prepi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PREPI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EPI Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Hibernation Peripheral Ready"]
    pub struct PRHIB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Hibernation Peripheral Ready"]
    pub mod prhib {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRHIB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Hibernation Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Peripheral Ready"]
    pub struct PRUART {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Asynchronous Receiver/Transmitter Peripheral Ready"]
    pub mod pruart {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRUART {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - UART Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - UART Module 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - UART Module 2 Peripheral Ready"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - UART Module 3 Peripheral Ready"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - UART Module 4 Peripheral Ready"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - UART Module 5 Peripheral Ready"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - UART Module 6 Peripheral Ready"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - UART Module 7 Peripheral Ready"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
        }
    }
    #[doc = "Synchronous Serial Interface Peripheral Ready"]
    pub struct PRSSI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Synchronous Serial Interface Peripheral Ready"]
    pub mod prssi {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRSSI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - SSI Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - SSI Module 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - SSI Module 2 Peripheral Ready"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - SSI Module 3 Peripheral Ready"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
        }
    }
    #[doc = "Inter-Integrated Circuit Peripheral Ready"]
    pub struct PRI2C {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Inter-Integrated Circuit Peripheral Ready"]
    pub mod pri2c {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRI2C {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R2R {
            bits: bool,
        }
        impl R2R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R3R {
            bits: bool,
        }
        impl R3R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R4R {
            bits: bool,
        }
        impl R4R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R5R {
            bits: bool,
        }
        impl R5R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R6R {
            bits: bool,
        }
        impl R6R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R7R {
            bits: bool,
        }
        impl R7R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R8R {
            bits: bool,
        }
        impl R8R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R9R {
            bits: bool,
        }
        impl R9R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - I2C Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - I2C Module 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
            #[doc = "Bit 2 - I2C Module 2 Peripheral Ready"]
            #[inline]
            pub fn r2(&self) -> R2R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 2;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R2R { bits }
            }
            #[doc = "Bit 3 - I2C Module 3 Peripheral Ready"]
            #[inline]
            pub fn r3(&self) -> R3R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 3;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R3R { bits }
            }
            #[doc = "Bit 4 - I2C Module 4 Peripheral Ready"]
            #[inline]
            pub fn r4(&self) -> R4R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R4R { bits }
            }
            #[doc = "Bit 5 - I2C Module 5 Peripheral Ready"]
            #[inline]
            pub fn r5(&self) -> R5R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 5;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R5R { bits }
            }
            #[doc = "Bit 6 - I2C Module 6 Peripheral Ready"]
            #[inline]
            pub fn r6(&self) -> R6R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 6;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R6R { bits }
            }
            #[doc = "Bit 7 - I2C Module 7 Peripheral Ready"]
            #[inline]
            pub fn r7(&self) -> R7R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R7R { bits }
            }
            #[doc = "Bit 8 - I2C Module 8 Peripheral Ready"]
            #[inline]
            pub fn r8(&self) -> R8R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R8R { bits }
            }
            #[doc = "Bit 9 - I2C Module 9 Peripheral Ready"]
            #[inline]
            pub fn r9(&self) -> R9R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R9R { bits }
            }
        }
    }
    #[doc = "Universal Serial Bus Peripheral Ready"]
    pub struct PRUSB {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Universal Serial Bus Peripheral Ready"]
    pub mod prusb {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRUSB {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - USB Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Ethernet PHY Peripheral Ready"]
    pub struct PREPHY {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet PHY Peripheral Ready"]
    pub mod prephy {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PREPHY {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet PHY Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Controller Area Network Peripheral Ready"]
    pub struct PRCAN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Controller Area Network Peripheral Ready"]
    pub mod prcan {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRCAN {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CAN Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - CAN Module 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
    }
    #[doc = "Analog-to-Digital Converter Peripheral Ready"]
    pub struct PRADC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog-to-Digital Converter Peripheral Ready"]
    pub mod pradc {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRADC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct R1R {
            bits: bool,
        }
        impl R1R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - ADC Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
            #[doc = "Bit 1 - ADC Module 1 Peripheral Ready"]
            #[inline]
            pub fn r1(&self) -> R1R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 1;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R1R { bits }
            }
        }
    }
    #[doc = "Analog Comparator Peripheral Ready"]
    pub struct PRACMP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Analog Comparator Peripheral Ready"]
    pub mod pracmp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRACMP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Analog Comparator Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Pulse Width Modulator Peripheral Ready"]
    pub struct PRPWM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Pulse Width Modulator Peripheral Ready"]
    pub mod prpwm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRPWM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - PWM Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Quadrature Encoder Interface Peripheral Ready"]
    pub struct PRQEI {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Quadrature Encoder Interface Peripheral Ready"]
    pub mod prqei {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRQEI {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - QEI Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "EEPROM Peripheral Ready"]
    pub struct PREEPROM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "EEPROM Peripheral Ready"]
    pub mod preeprom {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PREEPROM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - EEPROM Module Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "CRC and Cryptographic Modules Peripheral Ready"]
    pub struct PRCCM {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC and Cryptographic Modules Peripheral Ready"]
    pub mod prccm {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PRCCM {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - CRC and Cryptographic Modules Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
    #[doc = "Ethernet MAC Peripheral Ready"]
    pub struct PREMAC {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "Ethernet MAC Peripheral Ready"]
    pub mod premac {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::PREMAC {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct R0R {
            bits: bool,
        }
        impl R0R {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Ethernet MAC Module 0 Peripheral Ready"]
            #[inline]
            pub fn r0(&self) -> R0R {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                R0R { bits }
            }
        }
    }
}
#[doc = "Micro Direct Memory Access register addresses"]
pub struct UDMA {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for UDMA {}
impl UDMA {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const udma::RegisterBlock {
        0x400f_f000 as *const _
    }
}
impl Deref for UDMA {
    type Target = udma::RegisterBlock;
    fn deref(&self) -> &udma::RegisterBlock {
        unsafe { &*UDMA::ptr() }
    }
}
#[doc = "Micro Direct Memory Access register addresses"]
pub mod udma {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        #[doc = "0x00 - DMA Status"]
        pub stat: STAT,
        #[doc = "0x04 - DMA Configuration"]
        pub cfg: CFG,
        #[doc = "0x08 - DMA Channel Control Base Pointer"]
        pub ctlbase: CTLBASE,
        #[doc = "0x0c - DMA Alternate Channel Control Base Pointer"]
        pub altbase: ALTBASE,
        #[doc = "0x10 - DMA Channel Wait-on-Request Status"]
        pub waitstat: WAITSTAT,
        #[doc = "0x14 - DMA Channel Software Request"]
        pub swreq: SWREQ,
        #[doc = "0x18 - DMA Channel Useburst Set"]
        pub useburstset: USEBURSTSET,
        #[doc = "0x1c - DMA Channel Useburst Clear"]
        pub useburstclr: USEBURSTCLR,
        #[doc = "0x20 - DMA Channel Request Mask Set"]
        pub reqmaskset: REQMASKSET,
        #[doc = "0x24 - DMA Channel Request Mask Clear"]
        pub reqmaskclr: REQMASKCLR,
        #[doc = "0x28 - DMA Channel Enable Set"]
        pub enaset: ENASET,
        #[doc = "0x2c - DMA Channel Enable Clear"]
        pub enaclr: ENACLR,
        #[doc = "0x30 - DMA Channel Primary Alternate Set"]
        pub altset: ALTSET,
        #[doc = "0x34 - DMA Channel Primary Alternate Clear"]
        pub altclr: ALTCLR,
        #[doc = "0x38 - DMA Channel Priority Set"]
        pub prioset: PRIOSET,
        #[doc = "0x3c - DMA Channel Priority Clear"]
        pub prioclr: PRIOCLR,
        _reserved0: [u8; 12usize],
        #[doc = "0x4c - DMA Bus Error Clear"]
        pub errclr: ERRCLR,
        _reserved1: [u8; 1200usize],
        #[doc = "0x500 - DMA Channel Assignment"]
        pub chasgn: CHASGN,
        _reserved2: [u8; 12usize],
        #[doc = "0x510 - DMA Channel Map Select 0"]
        pub chmap0: CHMAP0,
        #[doc = "0x514 - DMA Channel Map Select 1"]
        pub chmap1: CHMAP1,
        #[doc = "0x518 - DMA Channel Map Select 2"]
        pub chmap2: CHMAP2,
        #[doc = "0x51c - DMA Channel Map Select 3"]
        pub chmap3: CHMAP3,
    }
    #[doc = "DMA Status"]
    pub struct STAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Status"]
    pub mod stat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::STAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct MASTENR {
            bits: bool,
        }
        impl MASTENR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `STATE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum STATER {
            #[doc = "Idle"]
            IDLE,
            #[doc = "Reading channel controller data"]
            RD_CTRL,
            #[doc = "Reading source end pointer"]
            RD_SRCENDP,
            #[doc = "Reading destination end pointer"]
            RD_DSTENDP,
            #[doc = "Reading source data"]
            RD_SRCDAT,
            #[doc = "Writing destination data"]
            WR_DSTDAT,
            #[doc = "Waiting for uDMA request to clear"]
            WAIT,
            #[doc = "Writing channel controller data"]
            WR_CTRL,
            #[doc = "Stalled"]
            STALL,
            #[doc = "Done"]
            DONE,
            #[doc = "Undefined"]
            UNDEF,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl STATER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    STATER::IDLE => 0,
                    STATER::RD_CTRL => 0x01,
                    STATER::RD_SRCENDP => 0x02,
                    STATER::RD_DSTENDP => 0x03,
                    STATER::RD_SRCDAT => 0x04,
                    STATER::WR_DSTDAT => 0x05,
                    STATER::WAIT => 0x06,
                    STATER::WR_CTRL => 0x07,
                    STATER::STALL => 0x08,
                    STATER::DONE => 0x09,
                    STATER::UNDEF => 0x0a,
                    STATER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> STATER {
                match value {
                    0 => STATER::IDLE,
                    1 => STATER::RD_CTRL,
                    2 => STATER::RD_SRCENDP,
                    3 => STATER::RD_DSTENDP,
                    4 => STATER::RD_SRCDAT,
                    5 => STATER::WR_DSTDAT,
                    6 => STATER::WAIT,
                    7 => STATER::WR_CTRL,
                    8 => STATER::STALL,
                    9 => STATER::DONE,
                    10 => STATER::UNDEF,
                    i => STATER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `IDLE`"]
            #[inline]
            pub fn is_idle(&self) -> bool {
                *self == STATER::IDLE
            }
            #[doc = "Checks if the value of the field is `RD_CTRL`"]
            #[inline]
            pub fn is_rd_ctrl(&self) -> bool {
                *self == STATER::RD_CTRL
            }
            #[doc = "Checks if the value of the field is `RD_SRCENDP`"]
            #[inline]
            pub fn is_rd_srcendp(&self) -> bool {
                *self == STATER::RD_SRCENDP
            }
            #[doc = "Checks if the value of the field is `RD_DSTENDP`"]
            #[inline]
            pub fn is_rd_dstendp(&self) -> bool {
                *self == STATER::RD_DSTENDP
            }
            #[doc = "Checks if the value of the field is `RD_SRCDAT`"]
            #[inline]
            pub fn is_rd_srcdat(&self) -> bool {
                *self == STATER::RD_SRCDAT
            }
            #[doc = "Checks if the value of the field is `WR_DSTDAT`"]
            #[inline]
            pub fn is_wr_dstdat(&self) -> bool {
                *self == STATER::WR_DSTDAT
            }
            #[doc = "Checks if the value of the field is `WAIT`"]
            #[inline]
            pub fn is_wait(&self) -> bool {
                *self == STATER::WAIT
            }
            #[doc = "Checks if the value of the field is `WR_CTRL`"]
            #[inline]
            pub fn is_wr_ctrl(&self) -> bool {
                *self == STATER::WR_CTRL
            }
            #[doc = "Checks if the value of the field is `STALL`"]
            #[inline]
            pub fn is_stall(&self) -> bool {
                *self == STATER::STALL
            }
            #[doc = "Checks if the value of the field is `DONE`"]
            #[inline]
            pub fn is_done(&self) -> bool {
                *self == STATER::DONE
            }
            #[doc = "Checks if the value of the field is `UNDEF`"]
            #[inline]
            pub fn is_undef(&self) -> bool {
                *self == STATER::UNDEF
            }
        }
        #[doc = r" Value of the field"]
        pub struct DMACHANSR {
            bits: u8,
        }
        impl DMACHANSR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - Master Enable Status"]
            #[inline]
            pub fn masten(&self) -> MASTENR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                MASTENR { bits }
            }
            #[doc = "Bits 4:7 - Control State Machine Status"]
            #[inline]
            pub fn state(&self) -> STATER {
                STATER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 16:20 - Available uDMA Channels Minus 1"]
            #[inline]
            pub fn dmachans(&self) -> DMACHANSR {
                let bits = {
                    const MASK: u8 = 0x1f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                DMACHANSR { bits }
            }
        }
    }
    #[doc = "DMA Configuration"]
    pub struct CFG {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Configuration"]
    pub mod cfg {
        #[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 _MASTENW<'a> {
            w: &'a mut W,
        }
        impl<'a> _MASTENW<'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 = "Bit 0 - Controller Master Enable"]
            #[inline]
            pub fn masten(&mut self) -> _MASTENW {
                _MASTENW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Control Base Pointer"]
    pub struct CTLBASE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Control Base Pointer"]
    pub mod ctlbase {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CTLBASE {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _ADDRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ADDRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0x003f_ffff;
                const OFFSET: u8 = 10;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 10:31 - Channel Control Base Address"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0x003f_ffff;
                    const OFFSET: u8 = 10;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
        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 10:31 - Channel Control Base Address"]
            #[inline]
            pub fn addr(&mut self) -> _ADDRW {
                _ADDRW { w: self }
            }
        }
    }
    #[doc = "DMA Alternate Channel Control Base Pointer"]
    pub struct ALTBASE {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Alternate Channel Control Base Pointer"]
    pub mod altbase {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::ALTBASE {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct ADDRR {
            bits: u32,
        }
        impl ADDRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Alternate Channel Address Pointer"]
            #[inline]
            pub fn addr(&self) -> ADDRR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                ADDRR { bits }
            }
        }
    }
    #[doc = "DMA Channel Wait-on-Request Status"]
    pub struct WAITSTAT {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Wait-on-Request Status"]
    pub mod waitstat {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::WAITSTAT {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct WAITREQR {
            bits: u32,
        }
        impl WAITREQR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Wait Status"]
            #[inline]
            pub fn waitreq(&self) -> WAITREQR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                WAITREQR { bits }
            }
        }
    }
    #[doc = "DMA Channel Software Request"]
    pub struct SWREQ {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Software Request"]
    pub mod swreq {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::SWREQ {
            #[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);
            }
        }
        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 = "DMA Channel Useburst Set"]
    pub struct USEBURSTSET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Useburst Set"]
    pub mod useburstset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USEBURSTSET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETR {
            bits: u32,
        }
        impl SETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Useburst Set"]
            #[inline]
            pub fn set(&self) -> SETR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SETR { bits }
            }
        }
        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 0:31 - Channel [n] Useburst Set"]
            #[inline]
            pub fn set(&mut self) -> _SETW {
                _SETW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Useburst Clear"]
    pub struct USEBURSTCLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Useburst Clear"]
    pub mod useburstclr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::USEBURSTCLR {
            #[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 _CLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Channel [n] Useburst Clear"]
            #[inline]
            pub fn clr(&mut self) -> _CLRW {
                _CLRW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Request Mask Set"]
    pub struct REQMASKSET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Request Mask Set"]
    pub mod reqmaskset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::REQMASKSET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETR {
            bits: u32,
        }
        impl SETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Request Mask Set"]
            #[inline]
            pub fn set(&self) -> SETR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SETR { bits }
            }
        }
        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 0:31 - Channel [n] Request Mask Set"]
            #[inline]
            pub fn set(&mut self) -> _SETW {
                _SETW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Request Mask Clear"]
    pub struct REQMASKCLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Request Mask Clear"]
    pub mod reqmaskclr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::REQMASKCLR {
            #[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 _CLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Channel [n] Request Mask Clear"]
            #[inline]
            pub fn clr(&mut self) -> _CLRW {
                _CLRW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Enable Set"]
    pub struct ENASET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Enable Set"]
    pub mod enaset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ENASET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETR {
            bits: u32,
        }
        impl SETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Enable Set"]
            #[inline]
            pub fn set(&self) -> SETR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SETR { bits }
            }
        }
        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 0:31 - Channel [n] Enable Set"]
            #[inline]
            pub fn set(&mut self) -> _SETW {
                _SETW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Enable Clear"]
    pub struct ENACLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Enable Clear"]
    pub mod enaclr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ENACLR {
            #[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 _CLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Clear Channel [n] Enable Clear"]
            #[inline]
            pub fn clr(&mut self) -> _CLRW {
                _CLRW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Primary Alternate Set"]
    pub struct ALTSET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Primary Alternate Set"]
    pub mod altset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ALTSET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETR {
            bits: u32,
        }
        impl SETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Alternate Set"]
            #[inline]
            pub fn set(&self) -> SETR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SETR { bits }
            }
        }
        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 0:31 - Channel [n] Alternate Set"]
            #[inline]
            pub fn set(&mut self) -> _SETW {
                _SETW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Primary Alternate Clear"]
    pub struct ALTCLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Primary Alternate Clear"]
    pub mod altclr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ALTCLR {
            #[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 _CLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Channel [n] Alternate Clear"]
            #[inline]
            pub fn clr(&mut self) -> _CLRW {
                _CLRW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Priority Set"]
    pub struct PRIOSET {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Priority Set"]
    pub mod prioset {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PRIOSET {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SETR {
            bits: u32,
        }
        impl SETR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SETW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SETW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Priority Set"]
            #[inline]
            pub fn set(&self) -> SETR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SETR { bits }
            }
        }
        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 0:31 - Channel [n] Priority Set"]
            #[inline]
            pub fn set(&mut self) -> _SETW {
                _SETW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Priority Clear"]
    pub struct PRIOCLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Priority Clear"]
    pub mod prioclr {
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::PRIOCLR {
            #[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 _CLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CLRW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                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 0:31 - Channel [n] Priority Clear"]
            #[inline]
            pub fn clr(&mut self) -> _CLRW {
                _CLRW { w: self }
            }
        }
    }
    #[doc = "DMA Bus Error Clear"]
    pub struct ERRCLR {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Bus Error Clear"]
    pub mod errclr {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::ERRCLR {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct ERRCLRR {
            bits: bool,
        }
        impl ERRCLRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Proxy"]
        pub struct _ERRCLRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ERRCLRW<'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 R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bit 0 - uDMA Bus Error Status"]
            #[inline]
            pub fn errclr(&self) -> ERRCLRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                ERRCLRR { bits }
            }
        }
        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 = "Bit 0 - uDMA Bus Error Status"]
            #[inline]
            pub fn errclr(&mut self) -> _ERRCLRW {
                _ERRCLRW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Assignment"]
    pub struct CHASGN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Assignment"]
    pub mod chasgn {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CHASGN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `CHASGN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum CHASGNR {
            #[doc = "Use the primary channel assignment"]
            PRIMARY,
            #[doc = "Use the secondary channel assignment"]
            SECONDARY,
            #[doc = r" Reserved"]
            _Reserved(u32),
        }
        impl CHASGNR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                match *self {
                    CHASGNR::PRIMARY => 0,
                    CHASGNR::SECONDARY => 0x01,
                    CHASGNR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u32) -> CHASGNR {
                match value {
                    0 => CHASGNR::PRIMARY,
                    1 => CHASGNR::SECONDARY,
                    i => CHASGNR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `PRIMARY`"]
            #[inline]
            pub fn is_primary(&self) -> bool {
                *self == CHASGNR::PRIMARY
            }
            #[doc = "Checks if the value of the field is `SECONDARY`"]
            #[inline]
            pub fn is_secondary(&self) -> bool {
                *self == CHASGNR::SECONDARY
            }
        }
        #[doc = "Values that can be written to the field `CHASGN`"]
        pub enum CHASGNW {
            #[doc = "Use the primary channel assignment"]
            PRIMARY,
            #[doc = "Use the secondary channel assignment"]
            SECONDARY,
        }
        impl CHASGNW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u32 {
                match *self {
                    CHASGNW::PRIMARY => 0,
                    CHASGNW::SECONDARY => 1,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _CHASGNW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CHASGNW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: CHASGNW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use the primary channel assignment"]
            #[inline]
            pub fn primary(self) -> &'a mut W {
                self.variant(CHASGNW::PRIMARY)
            }
            #[doc = "Use the secondary channel assignment"]
            #[inline]
            pub fn secondary(self) -> &'a mut W {
                self.variant(CHASGNW::SECONDARY)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Channel [n] Assignment Select"]
            #[inline]
            pub fn chasgn(&self) -> CHASGNR {
                CHASGNR::_from({
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                })
            }
        }
        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 0:31 - Channel [n] Assignment Select"]
            #[inline]
            pub fn chasgn(&mut self) -> _CHASGNW {
                _CHASGNW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Map Select 0"]
    pub struct CHMAP0 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Map Select 0"]
    pub mod chmap0 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CHMAP0 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH0SELR {
            bits: u8,
        }
        impl CH0SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH1SELR {
            bits: u8,
        }
        impl CH1SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH2SELR {
            bits: u8,
        }
        impl CH2SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH3SELR {
            bits: u8,
        }
        impl CH3SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH4SELR {
            bits: u8,
        }
        impl CH4SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH5SELR {
            bits: u8,
        }
        impl CH5SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH6SELR {
            bits: u8,
        }
        impl CH6SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH7SELR {
            bits: u8,
        }
        impl CH7SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH0SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH0SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH1SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH1SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH2SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH2SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _CH3SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH3SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH4SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH4SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH5SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH5SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH6SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH6SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH7SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH7SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - uDMA Channel 0 Source Select"]
            #[inline]
            pub fn ch0sel(&self) -> CH0SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH0SELR { bits }
            }
            #[doc = "Bits 4:7 - uDMA Channel 1 Source Select"]
            #[inline]
            pub fn ch1sel(&self) -> CH1SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH1SELR { bits }
            }
            #[doc = "Bits 8:11 - uDMA Channel 2 Source Select"]
            #[inline]
            pub fn ch2sel(&self) -> CH2SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH2SELR { bits }
            }
            #[doc = "Bits 12:15 - uDMA Channel 3 Source Select"]
            #[inline]
            pub fn ch3sel(&self) -> CH3SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH3SELR { bits }
            }
            #[doc = "Bits 16:19 - uDMA Channel 4 Source Select"]
            #[inline]
            pub fn ch4sel(&self) -> CH4SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH4SELR { bits }
            }
            #[doc = "Bits 20:23 - uDMA Channel 5 Source Select"]
            #[inline]
            pub fn ch5sel(&self) -> CH5SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH5SELR { bits }
            }
            #[doc = "Bits 24:27 - uDMA Channel 6 Source Select"]
            #[inline]
            pub fn ch6sel(&self) -> CH6SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH6SELR { bits }
            }
            #[doc = "Bits 28:31 - uDMA Channel 7 Source Select"]
            #[inline]
            pub fn ch7sel(&self) -> CH7SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH7SELR { bits }
            }
        }
        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 0:3 - uDMA Channel 0 Source Select"]
            #[inline]
            pub fn ch0sel(&mut self) -> _CH0SELW {
                _CH0SELW { w: self }
            }
            #[doc = "Bits 4:7 - uDMA Channel 1 Source Select"]
            #[inline]
            pub fn ch1sel(&mut self) -> _CH1SELW {
                _CH1SELW { w: self }
            }
            #[doc = "Bits 8:11 - uDMA Channel 2 Source Select"]
            #[inline]
            pub fn ch2sel(&mut self) -> _CH2SELW {
                _CH2SELW { w: self }
            }
            #[doc = "Bits 12:15 - uDMA Channel 3 Source Select"]
            #[inline]
            pub fn ch3sel(&mut self) -> _CH3SELW {
                _CH3SELW { w: self }
            }
            #[doc = "Bits 16:19 - uDMA Channel 4 Source Select"]
            #[inline]
            pub fn ch4sel(&mut self) -> _CH4SELW {
                _CH4SELW { w: self }
            }
            #[doc = "Bits 20:23 - uDMA Channel 5 Source Select"]
            #[inline]
            pub fn ch5sel(&mut self) -> _CH5SELW {
                _CH5SELW { w: self }
            }
            #[doc = "Bits 24:27 - uDMA Channel 6 Source Select"]
            #[inline]
            pub fn ch6sel(&mut self) -> _CH6SELW {
                _CH6SELW { w: self }
            }
            #[doc = "Bits 28:31 - uDMA Channel 7 Source Select"]
            #[inline]
            pub fn ch7sel(&mut self) -> _CH7SELW {
                _CH7SELW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Map Select 1"]
    pub struct CHMAP1 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Map Select 1"]
    pub mod chmap1 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CHMAP1 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH8SELR {
            bits: u8,
        }
        impl CH8SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH9SELR {
            bits: u8,
        }
        impl CH9SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH10SELR {
            bits: u8,
        }
        impl CH10SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH11SELR {
            bits: u8,
        }
        impl CH11SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH12SELR {
            bits: u8,
        }
        impl CH12SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH13SELR {
            bits: u8,
        }
        impl CH13SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH14SELR {
            bits: u8,
        }
        impl CH14SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH15SELR {
            bits: u8,
        }
        impl CH15SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH8SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH8SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH9SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH9SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH10SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH10SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _CH11SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH11SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH12SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH12SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH13SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH13SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH14SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH14SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH15SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH15SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - uDMA Channel 8 Source Select"]
            #[inline]
            pub fn ch8sel(&self) -> CH8SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH8SELR { bits }
            }
            #[doc = "Bits 4:7 - uDMA Channel 9 Source Select"]
            #[inline]
            pub fn ch9sel(&self) -> CH9SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH9SELR { bits }
            }
            #[doc = "Bits 8:11 - uDMA Channel 10 Source Select"]
            #[inline]
            pub fn ch10sel(&self) -> CH10SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH10SELR { bits }
            }
            #[doc = "Bits 12:15 - uDMA Channel 11 Source Select"]
            #[inline]
            pub fn ch11sel(&self) -> CH11SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH11SELR { bits }
            }
            #[doc = "Bits 16:19 - uDMA Channel 12 Source Select"]
            #[inline]
            pub fn ch12sel(&self) -> CH12SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH12SELR { bits }
            }
            #[doc = "Bits 20:23 - uDMA Channel 13 Source Select"]
            #[inline]
            pub fn ch13sel(&self) -> CH13SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH13SELR { bits }
            }
            #[doc = "Bits 24:27 - uDMA Channel 14 Source Select"]
            #[inline]
            pub fn ch14sel(&self) -> CH14SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH14SELR { bits }
            }
            #[doc = "Bits 28:31 - uDMA Channel 15 Source Select"]
            #[inline]
            pub fn ch15sel(&self) -> CH15SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH15SELR { bits }
            }
        }
        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 0:3 - uDMA Channel 8 Source Select"]
            #[inline]
            pub fn ch8sel(&mut self) -> _CH8SELW {
                _CH8SELW { w: self }
            }
            #[doc = "Bits 4:7 - uDMA Channel 9 Source Select"]
            #[inline]
            pub fn ch9sel(&mut self) -> _CH9SELW {
                _CH9SELW { w: self }
            }
            #[doc = "Bits 8:11 - uDMA Channel 10 Source Select"]
            #[inline]
            pub fn ch10sel(&mut self) -> _CH10SELW {
                _CH10SELW { w: self }
            }
            #[doc = "Bits 12:15 - uDMA Channel 11 Source Select"]
            #[inline]
            pub fn ch11sel(&mut self) -> _CH11SELW {
                _CH11SELW { w: self }
            }
            #[doc = "Bits 16:19 - uDMA Channel 12 Source Select"]
            #[inline]
            pub fn ch12sel(&mut self) -> _CH12SELW {
                _CH12SELW { w: self }
            }
            #[doc = "Bits 20:23 - uDMA Channel 13 Source Select"]
            #[inline]
            pub fn ch13sel(&mut self) -> _CH13SELW {
                _CH13SELW { w: self }
            }
            #[doc = "Bits 24:27 - uDMA Channel 14 Source Select"]
            #[inline]
            pub fn ch14sel(&mut self) -> _CH14SELW {
                _CH14SELW { w: self }
            }
            #[doc = "Bits 28:31 - uDMA Channel 15 Source Select"]
            #[inline]
            pub fn ch15sel(&mut self) -> _CH15SELW {
                _CH15SELW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Map Select 2"]
    pub struct CHMAP2 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Map Select 2"]
    pub mod chmap2 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CHMAP2 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH16SELR {
            bits: u8,
        }
        impl CH16SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH17SELR {
            bits: u8,
        }
        impl CH17SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH18SELR {
            bits: u8,
        }
        impl CH18SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH19SELR {
            bits: u8,
        }
        impl CH19SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH20SELR {
            bits: u8,
        }
        impl CH20SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH21SELR {
            bits: u8,
        }
        impl CH21SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH22SELR {
            bits: u8,
        }
        impl CH22SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH23SELR {
            bits: u8,
        }
        impl CH23SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH16SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH16SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH17SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH17SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH18SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH18SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _CH19SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH19SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH20SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH20SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH21SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH21SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH22SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH22SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH23SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH23SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - uDMA Channel 16 Source Select"]
            #[inline]
            pub fn ch16sel(&self) -> CH16SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH16SELR { bits }
            }
            #[doc = "Bits 4:7 - uDMA Channel 17 Source Select"]
            #[inline]
            pub fn ch17sel(&self) -> CH17SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH17SELR { bits }
            }
            #[doc = "Bits 8:11 - uDMA Channel 18 Source Select"]
            #[inline]
            pub fn ch18sel(&self) -> CH18SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH18SELR { bits }
            }
            #[doc = "Bits 12:15 - uDMA Channel 19 Source Select"]
            #[inline]
            pub fn ch19sel(&self) -> CH19SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH19SELR { bits }
            }
            #[doc = "Bits 16:19 - uDMA Channel 20 Source Select"]
            #[inline]
            pub fn ch20sel(&self) -> CH20SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH20SELR { bits }
            }
            #[doc = "Bits 20:23 - uDMA Channel 21 Source Select"]
            #[inline]
            pub fn ch21sel(&self) -> CH21SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH21SELR { bits }
            }
            #[doc = "Bits 24:27 - uDMA Channel 22 Source Select"]
            #[inline]
            pub fn ch22sel(&self) -> CH22SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH22SELR { bits }
            }
            #[doc = "Bits 28:31 - uDMA Channel 23 Source Select"]
            #[inline]
            pub fn ch23sel(&self) -> CH23SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH23SELR { bits }
            }
        }
        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 0:3 - uDMA Channel 16 Source Select"]
            #[inline]
            pub fn ch16sel(&mut self) -> _CH16SELW {
                _CH16SELW { w: self }
            }
            #[doc = "Bits 4:7 - uDMA Channel 17 Source Select"]
            #[inline]
            pub fn ch17sel(&mut self) -> _CH17SELW {
                _CH17SELW { w: self }
            }
            #[doc = "Bits 8:11 - uDMA Channel 18 Source Select"]
            #[inline]
            pub fn ch18sel(&mut self) -> _CH18SELW {
                _CH18SELW { w: self }
            }
            #[doc = "Bits 12:15 - uDMA Channel 19 Source Select"]
            #[inline]
            pub fn ch19sel(&mut self) -> _CH19SELW {
                _CH19SELW { w: self }
            }
            #[doc = "Bits 16:19 - uDMA Channel 20 Source Select"]
            #[inline]
            pub fn ch20sel(&mut self) -> _CH20SELW {
                _CH20SELW { w: self }
            }
            #[doc = "Bits 20:23 - uDMA Channel 21 Source Select"]
            #[inline]
            pub fn ch21sel(&mut self) -> _CH21SELW {
                _CH21SELW { w: self }
            }
            #[doc = "Bits 24:27 - uDMA Channel 22 Source Select"]
            #[inline]
            pub fn ch22sel(&mut self) -> _CH22SELW {
                _CH22SELW { w: self }
            }
            #[doc = "Bits 28:31 - uDMA Channel 23 Source Select"]
            #[inline]
            pub fn ch23sel(&mut self) -> _CH23SELW {
                _CH23SELW { w: self }
            }
        }
    }
    #[doc = "DMA Channel Map Select 3"]
    pub struct CHMAP3 {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "DMA Channel Map Select 3"]
    pub mod chmap3 {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CHMAP3 {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH24SELR {
            bits: u8,
        }
        impl CH24SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH25SELR {
            bits: u8,
        }
        impl CH25SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH26SELR {
            bits: u8,
        }
        impl CH26SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH27SELR {
            bits: u8,
        }
        impl CH27SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH28SELR {
            bits: u8,
        }
        impl CH28SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH29SELR {
            bits: u8,
        }
        impl CH29SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH30SELR {
            bits: u8,
        }
        impl CH30SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Value of the field"]
        pub struct CH31SELR {
            bits: u8,
        }
        impl CH31SELR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH24SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH24SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH25SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH25SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH26SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH26SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                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 _CH27SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH27SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH28SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH28SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 16;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH29SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH29SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 20;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH30SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH30SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 24;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _CH31SELW<'a> {
            w: &'a mut W,
        }
        impl<'a> _CH31SELW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 28;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - uDMA Channel 24 Source Select"]
            #[inline]
            pub fn ch24sel(&self) -> CH24SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH24SELR { bits }
            }
            #[doc = "Bits 4:7 - uDMA Channel 25 Source Select"]
            #[inline]
            pub fn ch25sel(&self) -> CH25SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH25SELR { bits }
            }
            #[doc = "Bits 8:11 - uDMA Channel 26 Source Select"]
            #[inline]
            pub fn ch26sel(&self) -> CH26SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH26SELR { bits }
            }
            #[doc = "Bits 12:15 - uDMA Channel 27 Source Select"]
            #[inline]
            pub fn ch27sel(&self) -> CH27SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH27SELR { bits }
            }
            #[doc = "Bits 16:19 - uDMA Channel 28 Source Select"]
            #[inline]
            pub fn ch28sel(&self) -> CH28SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 16;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH28SELR { bits }
            }
            #[doc = "Bits 20:23 - uDMA Channel 29 Source Select"]
            #[inline]
            pub fn ch29sel(&self) -> CH29SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 20;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH29SELR { bits }
            }
            #[doc = "Bits 24:27 - uDMA Channel 30 Source Select"]
            #[inline]
            pub fn ch30sel(&self) -> CH30SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 24;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH30SELR { bits }
            }
            #[doc = "Bits 28:31 - uDMA Channel 31 Source Select"]
            #[inline]
            pub fn ch31sel(&self) -> CH31SELR {
                let bits = {
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 28;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                };
                CH31SELR { bits }
            }
        }
        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 0:3 - uDMA Channel 24 Source Select"]
            #[inline]
            pub fn ch24sel(&mut self) -> _CH24SELW {
                _CH24SELW { w: self }
            }
            #[doc = "Bits 4:7 - uDMA Channel 25 Source Select"]
            #[inline]
            pub fn ch25sel(&mut self) -> _CH25SELW {
                _CH25SELW { w: self }
            }
            #[doc = "Bits 8:11 - uDMA Channel 26 Source Select"]
            #[inline]
            pub fn ch26sel(&mut self) -> _CH26SELW {
                _CH26SELW { w: self }
            }
            #[doc = "Bits 12:15 - uDMA Channel 27 Source Select"]
            #[inline]
            pub fn ch27sel(&mut self) -> _CH27SELW {
                _CH27SELW { w: self }
            }
            #[doc = "Bits 16:19 - uDMA Channel 28 Source Select"]
            #[inline]
            pub fn ch28sel(&mut self) -> _CH28SELW {
                _CH28SELW { w: self }
            }
            #[doc = "Bits 20:23 - uDMA Channel 29 Source Select"]
            #[inline]
            pub fn ch29sel(&mut self) -> _CH29SELW {
                _CH29SELW { w: self }
            }
            #[doc = "Bits 24:27 - uDMA Channel 30 Source Select"]
            #[inline]
            pub fn ch30sel(&mut self) -> _CH30SELW {
                _CH30SELW { w: self }
            }
            #[doc = "Bits 28:31 - uDMA Channel 31 Source Select"]
            #[inline]
            pub fn ch31sel(&mut self) -> _CH31SELW {
                _CH31SELW { w: self }
            }
        }
    }
}
#[doc = "EC register offsets"]
pub struct CCM0 {
    _marker: PhantomData<*const ()>,
}
unsafe impl Send for CCM0 {}
impl CCM0 {
    #[doc = r" Returns a pointer to the register block"]
    pub fn ptr() -> *const ccm0::RegisterBlock {
        0x4403_0000 as *const _
    }
}
impl Deref for CCM0 {
    type Target = ccm0::RegisterBlock;
    fn deref(&self) -> &ccm0::RegisterBlock {
        unsafe { &*CCM0::ptr() }
    }
}
#[doc = "EC register offsets"]
pub mod ccm0 {
    #[doc = r" Register block"]
    #[repr(C)]
    pub struct RegisterBlock {
        _reserved0: [u8; 1024usize],
        #[doc = "0x400 - CRC Control"]
        pub crcctrl: CRCCTRL,
        _reserved1: [u8; 12usize],
        #[doc = "0x410 - CRC SEED/Context"]
        pub crcseed: CRCSEED,
        #[doc = "0x414 - CRC Data Input"]
        pub crcdin: CRCDIN,
        #[doc = "0x418 - CRC Post Processing Result"]
        pub crcrsltpp: CRCRSLTPP,
    }
    #[doc = "CRC Control"]
    pub struct CRCCTRL {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC Control"]
    pub mod crcctrl {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CRCCTRL {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = "Possible values of the field `TYPE`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum TYPER {
            #[doc = "Polynomial 0x8005"]
            P8055,
            #[doc = "Polynomial 0x1021"]
            P1021,
            #[doc = "Polynomial 0x4C11DB7"]
            P4C11DB7,
            #[doc = "Polynomial 0x1EDC6F41"]
            P1EDC6F41,
            #[doc = "TCP checksum"]
            TCPCHKSUM,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl TYPER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    TYPER::P8055 => 0,
                    TYPER::P1021 => 0x01,
                    TYPER::P4C11DB7 => 0x02,
                    TYPER::P1EDC6F41 => 0x03,
                    TYPER::TCPCHKSUM => 0x08,
                    TYPER::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> TYPER {
                match value {
                    0 => TYPER::P8055,
                    1 => TYPER::P1021,
                    2 => TYPER::P4C11DB7,
                    3 => TYPER::P1EDC6F41,
                    8 => TYPER::TCPCHKSUM,
                    i => TYPER::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `P8055`"]
            #[inline]
            pub fn is_p8055(&self) -> bool {
                *self == TYPER::P8055
            }
            #[doc = "Checks if the value of the field is `P1021`"]
            #[inline]
            pub fn is_p1021(&self) -> bool {
                *self == TYPER::P1021
            }
            #[doc = "Checks if the value of the field is `P4C11DB7`"]
            #[inline]
            pub fn is_p4c11db7(&self) -> bool {
                *self == TYPER::P4C11DB7
            }
            #[doc = "Checks if the value of the field is `P1EDC6F41`"]
            #[inline]
            pub fn is_p1edc6f41(&self) -> bool {
                *self == TYPER::P1EDC6F41
            }
            #[doc = "Checks if the value of the field is `TCPCHKSUM`"]
            #[inline]
            pub fn is_tcpchksum(&self) -> bool {
                *self == TYPER::TCPCHKSUM
            }
        }
        #[doc = "Possible values of the field `ENDIAN`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum ENDIANR {
            #[doc = "Configuration unchanged. (B3, B2, B1, B0)"]
            SBHW,
            #[doc = "Bytes are swapped in half-words but half-words are not swapped (B2, B3, B0, B1)"]
            SHW,
            #[doc = "Half-words are swapped but bytes are not swapped in half-word. (B1, B0, B3, B2)"]
            SHWNB,
            #[doc = "Bytes are swapped in half-words and half-words are swapped. (B0, B1, B2, B3)"]
            SBSW,
        }
        impl ENDIANR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    ENDIANR::SBHW => 0,
                    ENDIANR::SHW => 0x01,
                    ENDIANR::SHWNB => 0x02,
                    ENDIANR::SBSW => 0x03,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> ENDIANR {
                match value {
                    0 => ENDIANR::SBHW,
                    1 => ENDIANR::SHW,
                    2 => ENDIANR::SHWNB,
                    3 => ENDIANR::SBSW,
                    _ => unreachable!(),
                }
            }
            #[doc = "Checks if the value of the field is `SBHW`"]
            #[inline]
            pub fn is_sbhw(&self) -> bool {
                *self == ENDIANR::SBHW
            }
            #[doc = "Checks if the value of the field is `SHW`"]
            #[inline]
            pub fn is_shw(&self) -> bool {
                *self == ENDIANR::SHW
            }
            #[doc = "Checks if the value of the field is `SHWNB`"]
            #[inline]
            pub fn is_shwnb(&self) -> bool {
                *self == ENDIANR::SHWNB
            }
            #[doc = "Checks if the value of the field is `SBSW`"]
            #[inline]
            pub fn is_sbsw(&self) -> bool {
                *self == ENDIANR::SBSW
            }
        }
        #[doc = r" Value of the field"]
        pub struct BRR {
            bits: bool,
        }
        impl BRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct OBRR {
            bits: bool,
        }
        impl OBRR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct RESINVR {
            bits: bool,
        }
        impl RESINVR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = r" Value of the field"]
        pub struct SIZER {
            bits: bool,
        }
        impl SIZER {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bit(&self) -> bool {
                self.bits
            }
            #[doc = r" Returns `true` if the bit is clear (0)"]
            #[inline]
            pub fn bit_is_clear(&self) -> bool {
                !self.bit()
            }
            #[doc = r" Returns `true` if the bit is set (1)"]
            #[inline]
            pub fn bit_is_set(&self) -> bool {
                self.bit()
            }
        }
        #[doc = "Possible values of the field `INIT`"]
        #[derive(Clone, Copy, Debug, PartialEq)]
        pub enum INITR {
            #[doc = "Use the CRCSEED register context as the starting value"]
            SEED,
            #[doc = "Initialize to all '0s'"]
            _0,
            #[doc = "Initialize to all '1s'"]
            _1,
            #[doc = r" Reserved"]
            _Reserved(u8),
        }
        impl INITR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u8 {
                match *self {
                    INITR::SEED => 0,
                    INITR::_0 => 0x02,
                    INITR::_1 => 0x03,
                    INITR::_Reserved(bits) => bits,
                }
            }
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _from(value: u8) -> INITR {
                match value {
                    0 => INITR::SEED,
                    2 => INITR::_0,
                    3 => INITR::_1,
                    i => INITR::_Reserved(i),
                }
            }
            #[doc = "Checks if the value of the field is `SEED`"]
            #[inline]
            pub fn is_seed(&self) -> bool {
                *self == INITR::SEED
            }
            #[doc = "Checks if the value of the field is `_0`"]
            #[inline]
            pub fn is_0(&self) -> bool {
                *self == INITR::_0
            }
            #[doc = "Checks if the value of the field is `_1`"]
            #[inline]
            pub fn is_1(&self) -> bool {
                *self == INITR::_1
            }
        }
        #[doc = "Values that can be written to the field `TYPE`"]
        pub enum TYPEW {
            #[doc = "Polynomial 0x8005"]
            P8055,
            #[doc = "Polynomial 0x1021"]
            P1021,
            #[doc = "Polynomial 0x4C11DB7"]
            P4C11DB7,
            #[doc = "Polynomial 0x1EDC6F41"]
            P1EDC6F41,
            #[doc = "TCP checksum"]
            TCPCHKSUM,
        }
        impl TYPEW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    TYPEW::P8055 => 0,
                    TYPEW::P1021 => 1,
                    TYPEW::P4C11DB7 => 2,
                    TYPEW::P1EDC6F41 => 3,
                    TYPEW::TCPCHKSUM => 8,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _TYPEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _TYPEW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: TYPEW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Polynomial 0x8005"]
            #[inline]
            pub fn p8055(self) -> &'a mut W {
                self.variant(TYPEW::P8055)
            }
            #[doc = "Polynomial 0x1021"]
            #[inline]
            pub fn p1021(self) -> &'a mut W {
                self.variant(TYPEW::P1021)
            }
            #[doc = "Polynomial 0x4C11DB7"]
            #[inline]
            pub fn p4c11db7(self) -> &'a mut W {
                self.variant(TYPEW::P4C11DB7)
            }
            #[doc = "Polynomial 0x1EDC6F41"]
            #[inline]
            pub fn p1edc6f41(self) -> &'a mut W {
                self.variant(TYPEW::P1EDC6F41)
            }
            #[doc = "TCP checksum"]
            #[inline]
            pub fn tcpchksum(self) -> &'a mut W {
                self.variant(TYPEW::TCPCHKSUM)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x0f;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `ENDIAN`"]
        pub enum ENDIANW {
            #[doc = "Configuration unchanged. (B3, B2, B1, B0)"]
            SBHW,
            #[doc = "Bytes are swapped in half-words but half-words are not swapped (B2, B3, B0, B1)"]
            SHW,
            #[doc = "Half-words are swapped but bytes are not swapped in half-word. (B1, B0, B3, B2)"]
            SHWNB,
            #[doc = "Bytes are swapped in half-words and half-words are swapped. (B0, B1, B2, B3)"]
            SBSW,
        }
        impl ENDIANW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    ENDIANW::SBHW => 0,
                    ENDIANW::SHW => 1,
                    ENDIANW::SHWNB => 2,
                    ENDIANW::SBSW => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _ENDIANW<'a> {
            w: &'a mut W,
        }
        impl<'a> _ENDIANW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: ENDIANW) -> &'a mut W {
                {
                    self.bits(variant._bits())
                }
            }
            #[doc = "Configuration unchanged. (B3, B2, B1, B0)"]
            #[inline]
            pub fn sbhw(self) -> &'a mut W {
                self.variant(ENDIANW::SBHW)
            }
            #[doc = "Bytes are swapped in half-words but half-words are not swapped (B2, B3, B0, B1)"]
            #[inline]
            pub fn shw(self) -> &'a mut W {
                self.variant(ENDIANW::SHW)
            }
            #[doc = "Half-words are swapped but bytes are not swapped in half-word. (B1, B0, B3, B2)"]
            #[inline]
            pub fn shwnb(self) -> &'a mut W {
                self.variant(ENDIANW::SHWNB)
            }
            #[doc = "Bytes are swapped in half-words and half-words are swapped. (B0, B1, B2, B3)"]
            #[inline]
            pub fn sbsw(self) -> &'a mut W {
                self.variant(ENDIANW::SBSW)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 4;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _BRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _BRW<'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 = 7;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _OBRW<'a> {
            w: &'a mut W,
        }
        impl<'a> _OBRW<'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 = 8;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _RESINVW<'a> {
            w: &'a mut W,
        }
        impl<'a> _RESINVW<'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 = 9;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = r" Proxy"]
        pub struct _SIZEW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SIZEW<'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 = 12;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        #[doc = "Values that can be written to the field `INIT`"]
        pub enum INITW {
            #[doc = "Use the CRCSEED register context as the starting value"]
            SEED,
            #[doc = "Initialize to all '0s'"]
            _0,
            #[doc = "Initialize to all '1s'"]
            _1,
        }
        impl INITW {
            #[allow(missing_docs)]
            #[doc(hidden)]
            #[inline]
            pub fn _bits(&self) -> u8 {
                match *self {
                    INITW::SEED => 0,
                    INITW::_0 => 2,
                    INITW::_1 => 3,
                }
            }
        }
        #[doc = r" Proxy"]
        pub struct _INITW<'a> {
            w: &'a mut W,
        }
        impl<'a> _INITW<'a> {
            #[doc = r" Writes `variant` to the field"]
            #[inline]
            pub fn variant(self, variant: INITW) -> &'a mut W {
                unsafe { self.bits(variant._bits()) }
            }
            #[doc = "Use the CRCSEED register context as the starting value"]
            #[inline]
            pub fn seed(self) -> &'a mut W {
                self.variant(INITW::SEED)
            }
            #[doc = "Initialize to all '0s'"]
            #[inline]
            pub fn _0(self) -> &'a mut W {
                self.variant(INITW::_0)
            }
            #[doc = "Initialize to all '1s'"]
            #[inline]
            pub fn _1(self) -> &'a mut W {
                self.variant(INITW::_1)
            }
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u8) -> &'a mut W {
                const MASK: u8 = 0x03;
                const OFFSET: u8 = 13;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:3 - Operation Type"]
            #[inline]
            pub fn type_(&self) -> TYPER {
                TYPER::_from({
                    const MASK: u8 = 0x0f;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bits 4:5 - Endian Control"]
            #[inline]
            pub fn endian(&self) -> ENDIANR {
                ENDIANR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 4;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
            #[doc = "Bit 7 - Bit reverse enable"]
            #[inline]
            pub fn br(&self) -> BRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 7;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                BRR { bits }
            }
            #[doc = "Bit 8 - Output Reverse Enable"]
            #[inline]
            pub fn obr(&self) -> OBRR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 8;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                OBRR { bits }
            }
            #[doc = "Bit 9 - Result Inverse Enable"]
            #[inline]
            pub fn resinv(&self) -> RESINVR {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 9;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                RESINVR { bits }
            }
            #[doc = "Bit 12 - Input Data Size"]
            #[inline]
            pub fn size(&self) -> SIZER {
                let bits = {
                    const MASK: bool = true;
                    const OFFSET: u8 = 12;
                    ((self.bits >> OFFSET) & MASK as u32) != 0
                };
                SIZER { bits }
            }
            #[doc = "Bits 13:14 - CRC Initialization"]
            #[inline]
            pub fn init(&self) -> INITR {
                INITR::_from({
                    const MASK: u8 = 0x03;
                    const OFFSET: u8 = 13;
                    ((self.bits >> OFFSET) & MASK as u32) as u8
                })
            }
        }
        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 0:3 - Operation Type"]
            #[inline]
            pub fn type_(&mut self) -> _TYPEW {
                _TYPEW { w: self }
            }
            #[doc = "Bits 4:5 - Endian Control"]
            #[inline]
            pub fn endian(&mut self) -> _ENDIANW {
                _ENDIANW { w: self }
            }
            #[doc = "Bit 7 - Bit reverse enable"]
            #[inline]
            pub fn br(&mut self) -> _BRW {
                _BRW { w: self }
            }
            #[doc = "Bit 8 - Output Reverse Enable"]
            #[inline]
            pub fn obr(&mut self) -> _OBRW {
                _OBRW { w: self }
            }
            #[doc = "Bit 9 - Result Inverse Enable"]
            #[inline]
            pub fn resinv(&mut self) -> _RESINVW {
                _RESINVW { w: self }
            }
            #[doc = "Bit 12 - Input Data Size"]
            #[inline]
            pub fn size(&mut self) -> _SIZEW {
                _SIZEW { w: self }
            }
            #[doc = "Bits 13:14 - CRC Initialization"]
            #[inline]
            pub fn init(&mut self) -> _INITW {
                _INITW { w: self }
            }
        }
    }
    #[doc = "CRC SEED/Context"]
    pub struct CRCSEED {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC SEED/Context"]
    pub mod crcseed {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CRCSEED {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct SEEDR {
            bits: u32,
        }
        impl SEEDR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _SEEDW<'a> {
            w: &'a mut W,
        }
        impl<'a> _SEEDW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - SEED/Context Value"]
            #[inline]
            pub fn seed(&self) -> SEEDR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                SEEDR { bits }
            }
        }
        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 0:31 - SEED/Context Value"]
            #[inline]
            pub fn seed(&mut self) -> _SEEDW {
                _SEEDW { w: self }
            }
        }
    }
    #[doc = "CRC Data Input"]
    pub struct CRCDIN {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC Data Input"]
    pub mod crcdin {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        #[doc = r" Value to write to the register"]
        pub struct W {
            bits: u32,
        }
        impl super::CRCDIN {
            #[doc = r" Modifies the contents of the register"]
            #[inline]
            pub fn modify<F>(&self, f: F)
            where
                for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
            {
                let bits = self.register.get();
                let r = R { bits: bits };
                let mut w = W { bits: bits };
                f(&r, &mut w);
                self.register.set(w.bits);
            }
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
            #[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" Writes the reset value to the register"]
            #[inline]
            pub fn reset(&self) {
                self.write(|w| w)
            }
        }
        #[doc = r" Value of the field"]
        pub struct DATAINR {
            bits: u32,
        }
        impl DATAINR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        #[doc = r" Proxy"]
        pub struct _DATAINW<'a> {
            w: &'a mut W,
        }
        impl<'a> _DATAINW<'a> {
            #[doc = r" Writes raw bits to the field"]
            #[inline]
            pub unsafe fn bits(self, value: u32) -> &'a mut W {
                const MASK: u32 = 0xffff_ffff;
                const OFFSET: u8 = 0;
                self.w.bits &= !((MASK as u32) << OFFSET);
                self.w.bits |= ((value & MASK) as u32) << OFFSET;
                self.w
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Data Input"]
            #[inline]
            pub fn datain(&self) -> DATAINR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                DATAINR { bits }
            }
        }
        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 0:31 - Data Input"]
            #[inline]
            pub fn datain(&mut self) -> _DATAINW {
                _DATAINW { w: self }
            }
        }
    }
    #[doc = "CRC Post Processing Result"]
    pub struct CRCRSLTPP {
        register: ::vcell::VolatileCell<u32>,
    }
    #[doc = "CRC Post Processing Result"]
    pub mod crcrsltpp {
        #[doc = r" Value read from the register"]
        pub struct R {
            bits: u32,
        }
        impl super::CRCRSLTPP {
            #[doc = r" Reads the contents of the register"]
            #[inline]
            pub fn read(&self) -> R {
                R { bits: self.register.get() }
            }
        }
        #[doc = r" Value of the field"]
        pub struct RSLTPPR {
            bits: u32,
        }
        impl RSLTPPR {
            #[doc = r" Value of the field as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
        }
        impl R {
            #[doc = r" Value of the register as raw bits"]
            #[inline]
            pub fn bits(&self) -> u32 {
                self.bits
            }
            #[doc = "Bits 0:31 - Post Processing Result"]
            #[inline]
            pub fn rsltpp(&self) -> RSLTPPR {
                let bits = {
                    const MASK: u32 = 0xffff_ffff;
                    const OFFSET: u8 = 0;
                    ((self.bits >> OFFSET) & MASK as u32) as u32
                };
                RSLTPPR { bits }
            }
        }
    }
}
#[no_mangle]
static mut DEVICE_PERIPHERALS: bool = false;
#[doc = r" All the peripherals"]
#[allow(non_snake_case)]
pub struct Peripherals {
    #[doc = "WATCHDOG0"]
    pub WATCHDOG0: WATCHDOG0,
    #[doc = "WATCHDOG1"]
    pub WATCHDOG1: WATCHDOG1,
    #[doc = "SSI0"]
    pub SSI0: SSI0,
    #[doc = "SSI1"]
    pub SSI1: SSI1,
    #[doc = "SSI2"]
    pub SSI2: SSI2,
    #[doc = "SSI3"]
    pub SSI3: SSI3,
    #[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 = "UART5"]
    pub UART5: UART5,
    #[doc = "UART6"]
    pub UART6: UART6,
    #[doc = "UART7"]
    pub UART7: UART7,
    #[doc = "I2C0"]
    pub I2C0: I2C0,
    #[doc = "I2C1"]
    pub I2C1: I2C1,
    #[doc = "I2C2"]
    pub I2C2: I2C2,
    #[doc = "I2C3"]
    pub I2C3: I2C3,
    #[doc = "PWM0"]
    pub PWM0: PWM0,
    #[doc = "QEI0"]
    pub QEI0: QEI0,
    #[doc = "TIMER0"]
    pub TIMER0: TIMER0,
    #[doc = "TIMER1"]
    pub TIMER1: TIMER1,
    #[doc = "TIMER2"]
    pub TIMER2: TIMER2,
    #[doc = "TIMER3"]
    pub TIMER3: TIMER3,
    #[doc = "TIMER4"]
    pub TIMER4: TIMER4,
    #[doc = "TIMER5"]
    pub TIMER5: TIMER5,
    #[doc = "ADC0"]
    pub ADC0: ADC0,
    #[doc = "ADC1"]
    pub ADC1: ADC1,
    #[doc = "COMP"]
    pub COMP: COMP,
    #[doc = "CAN0"]
    pub CAN0: CAN0,
    #[doc = "CAN1"]
    pub CAN1: CAN1,
    #[doc = "USB0"]
    pub USB0: USB0,
    #[doc = "GPIO_PORTA_AHB"]
    pub GPIO_PORTA_AHB: GPIO_PORTA_AHB,
    #[doc = "GPIO_PORTB_AHB"]
    pub GPIO_PORTB_AHB: GPIO_PORTB_AHB,
    #[doc = "GPIO_PORTC_AHB"]
    pub GPIO_PORTC_AHB: GPIO_PORTC_AHB,
    #[doc = "GPIO_PORTD_AHB"]
    pub GPIO_PORTD_AHB: GPIO_PORTD_AHB,
    #[doc = "GPIO_PORTE_AHB"]
    pub GPIO_PORTE_AHB: GPIO_PORTE_AHB,
    #[doc = "GPIO_PORTF_AHB"]
    pub GPIO_PORTF_AHB: GPIO_PORTF_AHB,
    #[doc = "GPIO_PORTG_AHB"]
    pub GPIO_PORTG_AHB: GPIO_PORTG_AHB,
    #[doc = "GPIO_PORTH_AHB"]
    pub GPIO_PORTH_AHB: GPIO_PORTH_AHB,
    #[doc = "GPIO_PORTJ_AHB"]
    pub GPIO_PORTJ_AHB: GPIO_PORTJ_AHB,
    #[doc = "GPIO_PORTK"]
    pub GPIO_PORTK: GPIO_PORTK,
    #[doc = "GPIO_PORTL"]
    pub GPIO_PORTL: GPIO_PORTL,
    #[doc = "GPIO_PORTM"]
    pub GPIO_PORTM: GPIO_PORTM,
    #[doc = "GPIO_PORTN"]
    pub GPIO_PORTN: GPIO_PORTN,
    #[doc = "GPIO_PORTP"]
    pub GPIO_PORTP: GPIO_PORTP,
    #[doc = "GPIO_PORTQ"]
    pub GPIO_PORTQ: GPIO_PORTQ,
    #[doc = "EEPROM"]
    pub EEPROM: EEPROM,
    #[doc = "I2C8"]
    pub I2C8: I2C8,
    #[doc = "I2C9"]
    pub I2C9: I2C9,
    #[doc = "I2C4"]
    pub I2C4: I2C4,
    #[doc = "I2C5"]
    pub I2C5: I2C5,
    #[doc = "I2C6"]
    pub I2C6: I2C6,
    #[doc = "I2C7"]
    pub I2C7: I2C7,
    #[doc = "EPI0"]
    pub EPI0: EPI0,
    #[doc = "TIMER6"]
    pub TIMER6: TIMER6,
    #[doc = "TIMER7"]
    pub TIMER7: TIMER7,
    #[doc = "EMAC0"]
    pub EMAC0: EMAC0,
    #[doc = "SYSEXC"]
    pub SYSEXC: SYSEXC,
    #[doc = "HIB"]
    pub HIB: HIB,
    #[doc = "FLASH_CTRL"]
    pub FLASH_CTRL: FLASH_CTRL,
    #[doc = "SYSCTL"]
    pub SYSCTL: SYSCTL,
    #[doc = "UDMA"]
    pub UDMA: UDMA,
    #[doc = "CCM0"]
    pub CCM0: CCM0,
}
impl Peripherals {
    #[doc = r" Returns all the peripherals *once*"]
    #[inline]
    pub fn take() -> Option<Self> {
        cortex_m::interrupt::free(|_| if unsafe { DEVICE_PERIPHERALS } { None } else { Some(unsafe { Peripherals::steal() }) })
    }
    #[doc = r" Unchecked version of `Peripherals::take`"]
    pub unsafe fn steal() -> Self {
        debug_assert!(!DEVICE_PERIPHERALS);
        DEVICE_PERIPHERALS = true;
        Peripherals {
            WATCHDOG0: WATCHDOG0 { _marker: PhantomData },
            WATCHDOG1: WATCHDOG1 { _marker: PhantomData },
            SSI0: SSI0 { _marker: PhantomData },
            SSI1: SSI1 { _marker: PhantomData },
            SSI2: SSI2 { _marker: PhantomData },
            SSI3: SSI3 { _marker: PhantomData },
            UART0: UART0 { _marker: PhantomData },
            UART1: UART1 { _marker: PhantomData },
            UART2: UART2 { _marker: PhantomData },
            UART3: UART3 { _marker: PhantomData },
            UART4: UART4 { _marker: PhantomData },
            UART5: UART5 { _marker: PhantomData },
            UART6: UART6 { _marker: PhantomData },
            UART7: UART7 { _marker: PhantomData },
            I2C0: I2C0 { _marker: PhantomData },
            I2C1: I2C1 { _marker: PhantomData },
            I2C2: I2C2 { _marker: PhantomData },
            I2C3: I2C3 { _marker: PhantomData },
            PWM0: PWM0 { _marker: PhantomData },
            QEI0: QEI0 { _marker: PhantomData },
            TIMER0: TIMER0 { _marker: PhantomData },
            TIMER1: TIMER1 { _marker: PhantomData },
            TIMER2: TIMER2 { _marker: PhantomData },
            TIMER3: TIMER3 { _marker: PhantomData },
            TIMER4: TIMER4 { _marker: PhantomData },
            TIMER5: TIMER5 { _marker: PhantomData },
            ADC0: ADC0 { _marker: PhantomData },
            ADC1: ADC1 { _marker: PhantomData },
            COMP: COMP { _marker: PhantomData },
            CAN0: CAN0 { _marker: PhantomData },
            CAN1: CAN1 { _marker: PhantomData },
            USB0: USB0 { _marker: PhantomData },
            GPIO_PORTA_AHB: GPIO_PORTA_AHB { _marker: PhantomData },
            GPIO_PORTB_AHB: GPIO_PORTB_AHB { _marker: PhantomData },
            GPIO_PORTC_AHB: GPIO_PORTC_AHB { _marker: PhantomData },
            GPIO_PORTD_AHB: GPIO_PORTD_AHB { _marker: PhantomData },
            GPIO_PORTE_AHB: GPIO_PORTE_AHB { _marker: PhantomData },
            GPIO_PORTF_AHB: GPIO_PORTF_AHB { _marker: PhantomData },
            GPIO_PORTG_AHB: GPIO_PORTG_AHB { _marker: PhantomData },
            GPIO_PORTH_AHB: GPIO_PORTH_AHB { _marker: PhantomData },
            GPIO_PORTJ_AHB: GPIO_PORTJ_AHB { _marker: PhantomData },
            GPIO_PORTK: GPIO_PORTK { _marker: PhantomData },
            GPIO_PORTL: GPIO_PORTL { _marker: PhantomData },
            GPIO_PORTM: GPIO_PORTM { _marker: PhantomData },
            GPIO_PORTN: GPIO_PORTN { _marker: PhantomData },
            GPIO_PORTP: GPIO_PORTP { _marker: PhantomData },
            GPIO_PORTQ: GPIO_PORTQ { _marker: PhantomData },
            EEPROM: EEPROM { _marker: PhantomData },
            I2C8: I2C8 { _marker: PhantomData },
            I2C9: I2C9 { _marker: PhantomData },
            I2C4: I2C4 { _marker: PhantomData },
            I2C5: I2C5 { _marker: PhantomData },
            I2C6: I2C6 { _marker: PhantomData },
            I2C7: I2C7 { _marker: PhantomData },
            EPI0: EPI0 { _marker: PhantomData },
            TIMER6: TIMER6 { _marker: PhantomData },
            TIMER7: TIMER7 { _marker: PhantomData },
            EMAC0: EMAC0 { _marker: PhantomData },
            SYSEXC: SYSEXC { _marker: PhantomData },
            HIB: HIB { _marker: PhantomData },
            FLASH_CTRL: FLASH_CTRL { _marker: PhantomData },
            SYSCTL: SYSCTL { _marker: PhantomData },
            UDMA: UDMA { _marker: PhantomData },
            CCM0: CCM0 { _marker: PhantomData },
        }
    }
}
