da14531-pac 0.2.0

/*
DISCLAIMER
This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
applicable laws, including copyright laws.
THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NON-INFRINGEMENT.  ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability
of this software. By using this software, you agree to the additional terms and conditions found by accessing the
following link:
http://www.renesas.com/disclaimer

*/
// Generated from SVD 1.2, with svd2pac 0.6.0 on Thu, 24 Jul 2025 04:44:12 +0000

#![allow(clippy::identity_op)]
#![allow(clippy::module_inception)]
#![allow(clippy::derivable_impls)]
#[allow(unused_imports)]
use crate::common::sealed;
#[allow(unused_imports)]
use crate::common::*;
#[doc = r"KBRD registers"]
unsafe impl ::core::marker::Send for super::Kbrd {}
unsafe impl ::core::marker::Sync for super::Kbrd {}
impl super::Kbrd {
    #[allow(unused)]
    #[inline(always)]
    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
        self.ptr
    }

    #[doc = "debounce counter value for GPIO inputs"]
    #[inline(always)]
    pub const fn gpio_debounce_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioDebounceReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioDebounceReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(12usize),
            )
        }
    }

    #[doc = "high or low level select for GPIO interrupts"]
    #[inline(always)]
    pub const fn gpio_int_level_ctrl_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIntLevelCtrlReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIntLevelCtrlReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(16usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for GPIO_IRQ0"]
    #[inline(always)]
    pub const fn gpio_irq0_in_sel_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIrq0InSelReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIrq0InSelReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(0usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for GPIO_IRQ1"]
    #[inline(always)]
    pub const fn gpio_irq1_in_sel_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIrq1InSelReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIrq1InSelReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(2usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for GPIO_IRQ2"]
    #[inline(always)]
    pub const fn gpio_irq2_in_sel_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIrq2InSelReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIrq2InSelReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(4usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for GPIO_IRQ3"]
    #[inline(always)]
    pub const fn gpio_irq3_in_sel_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIrq3InSelReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIrq3InSelReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(6usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for GPIO_IRQ4"]
    #[inline(always)]
    pub const fn gpio_irq4_in_sel_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioIrq4InSelReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioIrq4InSelReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(8usize),
            )
        }
    }

    #[doc = "GPIO interrupt reset register"]
    #[inline(always)]
    pub const fn gpio_reset_irq_reg(
        &self,
    ) -> &'static crate::common::Reg<self::GpioResetIrqReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::GpioResetIrqReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(14usize),
            )
        }
    }

    #[doc = "GPIO Kbrd control register"]
    #[inline(always)]
    pub const fn kbrd_ctrl_reg(
        &self,
    ) -> &'static crate::common::Reg<self::KbrdCtrlReg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::KbrdCtrlReg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(20usize),
            )
        }
    }

    #[doc = "GPIO interrupt selection for KBRD_IRQ for P0"]
    #[inline(always)]
    pub const fn kbrd_irq_in_sel0_reg(
        &self,
    ) -> &'static crate::common::Reg<self::KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::KbrdIrqInSel0Reg_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(18usize),
            )
        }
    }
}
#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioDebounceReg_SPEC;
impl crate::sealed::RegSpec for GpioDebounceReg_SPEC {
    type DataType = u16;
}

#[doc = "debounce counter value for GPIO inputs"]
pub type GpioDebounceReg = crate::RegValueT<GpioDebounceReg_SPEC>;

impl GpioDebounceReg {
    #[doc = "enables the debounce counter for the KBRD interface"]
    #[inline(always)]
    pub fn deb_enable_kbrd(
        self,
    ) -> crate::common::RegisterFieldBool<11, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<11,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enables the debounce counter for GPIO IRQ4"]
    #[inline(always)]
    pub fn deb_enable4(
        self,
    ) -> crate::common::RegisterFieldBool<10, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<10,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enables the debounce counter for GPIO IRQ3"]
    #[inline(always)]
    pub fn deb_enable3(
        self,
    ) -> crate::common::RegisterFieldBool<9, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<9,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enables the debounce counter for GPIO IRQ2"]
    #[inline(always)]
    pub fn deb_enable2(
        self,
    ) -> crate::common::RegisterFieldBool<8, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<8,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enables the debounce counter for GPIO IRQ1"]
    #[inline(always)]
    pub fn deb_enable1(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enables the debounce counter for GPIO IRQ0"]
    #[inline(always)]
    pub fn deb_enable0(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, GpioDebounceReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6,1,0,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Keyboard debounce time if enabled. Generate KEYB_INT after specified time.\nDebounce time: N*1 ms. N =0..63"]
    #[inline(always)]
    pub fn deb_value(
        self,
    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, GpioDebounceReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,GpioDebounceReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioDebounceReg {
    #[inline(always)]
    fn default() -> GpioDebounceReg {
        <crate::RegValueT<GpioDebounceReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIntLevelCtrlReg_SPEC;
impl crate::sealed::RegSpec for GpioIntLevelCtrlReg_SPEC {
    type DataType = u16;
}

#[doc = "high or low level select for GPIO interrupts"]
pub type GpioIntLevelCtrlReg = crate::RegValueT<GpioIntLevelCtrlReg_SPEC>;

impl GpioIntLevelCtrlReg {
    #[doc = "see EDGE_LEVELn0, but for GPIO IRQ4"]
    #[inline(always)]
    pub fn edge_leveln4(
        self,
    ) -> crate::common::RegisterFieldBool<9, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<9,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see EDGE_LEVELn0, but for GPIO IRQ3"]
    #[inline(always)]
    pub fn edge_leveln3(
        self,
    ) -> crate::common::RegisterFieldBool<8, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<8,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see EDGE_LEVELn0, but for GPIO IRQ2"]
    #[inline(always)]
    pub fn edge_leveln2(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<7,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see EDGE_LEVELn0, but for GPIO IRQ1"]
    #[inline(always)]
    pub fn edge_leveln1(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<6,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "0: do not wait for key release after interrupt was reset for GPIO IRQ0, so a new interrupt can be initiated immediately\n1: wait for key release after interrupt was reset for IRQ0"]
    #[inline(always)]
    pub fn edge_leveln0(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<5,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see INPUT_LEVEL0, but for GPIO IRQ4"]
    #[inline(always)]
    pub fn input_level4(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<4,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see INPUT_LEVEL0, but for GPIO IRQ3"]
    #[inline(always)]
    pub fn input_level3(
        self,
    ) -> crate::common::RegisterFieldBool<3, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<3,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see INPUT_LEVEL0, but for GPIO IRQ2"]
    #[inline(always)]
    pub fn input_level2(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<2,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see INPUT_LEVEL0, but for GPIO IRQ1"]
    #[inline(always)]
    pub fn input_level1(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<1,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "0 = selected input will generate GPIO IRQ0 if that input is high.\n1 = selected input will generate GPIO IRQ0 if that input is low."]
    #[inline(always)]
    pub fn input_level0(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, GpioIntLevelCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterFieldBool::<0,1,0,GpioIntLevelCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIntLevelCtrlReg {
    #[inline(always)]
    fn default() -> GpioIntLevelCtrlReg {
        <crate::RegValueT<GpioIntLevelCtrlReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIrq0InSelReg_SPEC;
impl crate::sealed::RegSpec for GpioIrq0InSelReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for GPIO_IRQ0"]
pub type GpioIrq0InSelReg = crate::RegValueT<GpioIrq0InSelReg_SPEC>;

impl GpioIrq0InSelReg {
    #[doc = "input selection that can generate a GPIO interrupt\n1: P0\\[0\\] is selected\n2: P0\\[1\\] is selected\n3: P0\\[2\\] is selected\n4: P0\\[3\\] is selected\n5: P0\\[4\\] is selected\n6: P0\\[5\\] is selected\n7: P0\\[6\\] is selected\n8: P0\\[7\\] is selected\n9: P0\\[8\\] is selected\n10: P0\\[9\\] is selected\n11: P0\\[10\\] is selected\n12: P0\\[11\\] is selected\nall others: no input selected"]
    #[inline(always)]
    pub fn kbrd_irq0_sel(
        self,
    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, GpioIrq0InSelReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0xf,1,0,u8,u8,GpioIrq0InSelReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIrq0InSelReg {
    #[inline(always)]
    fn default() -> GpioIrq0InSelReg {
        <crate::RegValueT<GpioIrq0InSelReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIrq1InSelReg_SPEC;
impl crate::sealed::RegSpec for GpioIrq1InSelReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for GPIO_IRQ1"]
pub type GpioIrq1InSelReg = crate::RegValueT<GpioIrq1InSelReg_SPEC>;

impl GpioIrq1InSelReg {
    #[doc = "see KBRD_IRQ0_SEL"]
    #[inline(always)]
    pub fn kbrd_irq1_sel(
        self,
    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, GpioIrq1InSelReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0xf,1,0,u8,u8,GpioIrq1InSelReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIrq1InSelReg {
    #[inline(always)]
    fn default() -> GpioIrq1InSelReg {
        <crate::RegValueT<GpioIrq1InSelReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIrq2InSelReg_SPEC;
impl crate::sealed::RegSpec for GpioIrq2InSelReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for GPIO_IRQ2"]
pub type GpioIrq2InSelReg = crate::RegValueT<GpioIrq2InSelReg_SPEC>;

impl GpioIrq2InSelReg {
    #[doc = "see KBRD_IRQ0_SEL"]
    #[inline(always)]
    pub fn kbrd_irq2_sel(
        self,
    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, GpioIrq2InSelReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0xf,1,0,u8,u8,GpioIrq2InSelReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIrq2InSelReg {
    #[inline(always)]
    fn default() -> GpioIrq2InSelReg {
        <crate::RegValueT<GpioIrq2InSelReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIrq3InSelReg_SPEC;
impl crate::sealed::RegSpec for GpioIrq3InSelReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for GPIO_IRQ3"]
pub type GpioIrq3InSelReg = crate::RegValueT<GpioIrq3InSelReg_SPEC>;

impl GpioIrq3InSelReg {
    #[doc = "see KBRD_IRQ0_SEL"]
    #[inline(always)]
    pub fn kbrd_irq3_sel(
        self,
    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, GpioIrq3InSelReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0xf,1,0,u8,u8,GpioIrq3InSelReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIrq3InSelReg {
    #[inline(always)]
    fn default() -> GpioIrq3InSelReg {
        <crate::RegValueT<GpioIrq3InSelReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioIrq4InSelReg_SPEC;
impl crate::sealed::RegSpec for GpioIrq4InSelReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for GPIO_IRQ4"]
pub type GpioIrq4InSelReg = crate::RegValueT<GpioIrq4InSelReg_SPEC>;

impl GpioIrq4InSelReg {
    #[doc = "see KBRD_IRQ0_SEL"]
    #[inline(always)]
    pub fn kbrd_irq4_sel(
        self,
    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, GpioIrq4InSelReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0xf,1,0,u8,u8,GpioIrq4InSelReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioIrq4InSelReg {
    #[inline(always)]
    fn default() -> GpioIrq4InSelReg {
        <crate::RegValueT<GpioIrq4InSelReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct GpioResetIrqReg_SPEC;
impl crate::sealed::RegSpec for GpioResetIrqReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt reset register"]
pub type GpioResetIrqReg = crate::RegValueT<GpioResetIrqReg_SPEC>;

impl GpioResetIrqReg {
    #[doc = "writing a 1 to this bit will reset the KBRD IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_kbrd_irq(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<5,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }

    #[doc = "writing a 1 to this bit will reset the GPIO4 IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_gpio4_irq(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<4,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }

    #[doc = "writing a 1 to this bit will reset the GPIO3 IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_gpio3_irq(
        self,
    ) -> crate::common::RegisterFieldBool<3, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<3,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }

    #[doc = "writing a 1 to this bit will reset the GPIO2 IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_gpio2_irq(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<2,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }

    #[doc = "writing a 1 to this bit will reset the GPIO1 IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_gpio1_irq(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<1,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }

    #[doc = "writing a 1 to this bit will reset the GPIO0 IRQ.\nReading returns 0."]
    #[inline(always)]
    pub fn reset_gpio0_irq(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, GpioResetIrqReg_SPEC, crate::common::W> {
        crate::common::RegisterFieldBool::<0,1,0,GpioResetIrqReg_SPEC,crate::common::W>::from_register(self,0)
    }
}
impl ::core::default::Default for GpioResetIrqReg {
    #[inline(always)]
    fn default() -> GpioResetIrqReg {
        <crate::RegValueT<GpioResetIrqReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct KbrdCtrlReg_SPEC;
impl crate::sealed::RegSpec for KbrdCtrlReg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO Kbrd control register"]
pub type KbrdCtrlReg = crate::RegValueT<KbrdCtrlReg_SPEC>;

impl KbrdCtrlReg {
    #[doc = "0 = No interrupt on key release\n1 = Interrupt also on key release (also debouncing if enabled)"]
    #[inline(always)]
    pub fn kbrd_rel(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, KbrdCtrlReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7,1,0,KbrdCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "0 = enabled input will generate KBRD IRQ if that input is high.\n1 = enabled input will generate KBRD IRQ if that input is low."]
    #[inline(always)]
    pub fn kbrd_level(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, KbrdCtrlReg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6,1,0,KbrdCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "While key is pressed, automatically generate repeating\nKEYB_INT after specified time unequal to 0.\nRepeat time: N*1 ms. N =1..63, N=0 disables the timer."]
    #[inline(always)]
    pub fn key_repeat(
        self,
    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, KbrdCtrlReg_SPEC, crate::common::RW>
    {
        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,KbrdCtrlReg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for KbrdCtrlReg {
    #[inline(always)]
    fn default() -> KbrdCtrlReg {
        <crate::RegValueT<KbrdCtrlReg_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct KbrdIrqInSel0Reg_SPEC;
impl crate::sealed::RegSpec for KbrdIrqInSel0Reg_SPEC {
    type DataType = u16;
}

#[doc = "GPIO interrupt selection for KBRD_IRQ for P0"]
pub type KbrdIrqInSel0Reg = crate::RegValueT<KbrdIrqInSel0Reg_SPEC>;

impl KbrdIrqInSel0Reg {
    #[doc = "enable P0\\[11\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p11_en(
        self,
    ) -> crate::common::RegisterFieldBool<11, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<11,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[10\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p10_en(
        self,
    ) -> crate::common::RegisterFieldBool<10, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<10,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[9\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p09_en(
        self,
    ) -> crate::common::RegisterFieldBool<9, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<9,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[8\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p08_en(
        self,
    ) -> crate::common::RegisterFieldBool<8, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<8,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[7\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p07_en(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[6\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p06_en(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[5\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p05_en(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[4\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p04_en(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<4,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[3\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p03_en(
        self,
    ) -> crate::common::RegisterFieldBool<3, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<3,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[2\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p02_en(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<2,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[1\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p01_en(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "enable P0\\[0\\] for the keyboard interrupt"]
    #[inline(always)]
    pub fn kbrd_p00_en(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, KbrdIrqInSel0Reg_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0,1,0,KbrdIrqInSel0Reg_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for KbrdIrqInSel0Reg {
    #[inline(always)]
    fn default() -> KbrdIrqInSel0Reg {
        <crate::RegValueT<KbrdIrqInSel0Reg_SPEC> as RegisterValue<_>>::new(0)
    }
}