#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r"Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::EXTICR3 {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = "Possible values of the field `EXTI11`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI11R {
#[doc = "Select PE11 as the source input for the EXTI11 external interrupt"]
PE11,
#[doc = "Select PA11 as the source input for the EXTI11 external interrupt"]
PA11,
#[doc = "Select PB11 as the source input for the EXTI11 external interrupt"]
PB11,
#[doc = "Select PC11 as the source input for the EXTI11 external interrupt"]
PC11,
#[doc = "Select PD11 as the source input for the EXTI11 external interrupt"]
PD11,
#[doc = "Select PF11 as the source input for the EXTI11 external interrupt"]
PF11,
#[doc = r"Reserved"]
_Reserved(u8),
}
impl EXTI11R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
EXTI11R::PE11 => 0x04,
EXTI11R::PA11 => 0,
EXTI11R::PB11 => 0x01,
EXTI11R::PC11 => 0x02,
EXTI11R::PD11 => 0x03,
EXTI11R::PF11 => 0x05,
EXTI11R::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> EXTI11R {
match value {
4 => EXTI11R::PE11,
0 => EXTI11R::PA11,
1 => EXTI11R::PB11,
2 => EXTI11R::PC11,
3 => EXTI11R::PD11,
5 => EXTI11R::PF11,
i => EXTI11R::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `PE11`"]
#[inline(always)]
pub fn is_pe11(&self) -> bool {
*self == EXTI11R::PE11
}
#[doc = "Checks if the value of the field is `PA11`"]
#[inline(always)]
pub fn is_pa11(&self) -> bool {
*self == EXTI11R::PA11
}
#[doc = "Checks if the value of the field is `PB11`"]
#[inline(always)]
pub fn is_pb11(&self) -> bool {
*self == EXTI11R::PB11
}
#[doc = "Checks if the value of the field is `PC11`"]
#[inline(always)]
pub fn is_pc11(&self) -> bool {
*self == EXTI11R::PC11
}
#[doc = "Checks if the value of the field is `PD11`"]
#[inline(always)]
pub fn is_pd11(&self) -> bool {
*self == EXTI11R::PD11
}
#[doc = "Checks if the value of the field is `PF11`"]
#[inline(always)]
pub fn is_pf11(&self) -> bool {
*self == EXTI11R::PF11
}
}
#[doc = "Values that can be written to the field `EXTI11`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI11W {
#[doc = "Select PE11 as the source input for the EXTI11 external interrupt"]
PE11,
#[doc = "Select PA11 as the source input for the EXTI11 external interrupt"]
PA11,
#[doc = "Select PB11 as the source input for the EXTI11 external interrupt"]
PB11,
#[doc = "Select PC11 as the source input for the EXTI11 external interrupt"]
PC11,
#[doc = "Select PD11 as the source input for the EXTI11 external interrupt"]
PD11,
#[doc = "Select PF11 as the source input for the EXTI11 external interrupt"]
PF11,
}
impl EXTI11W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
EXTI11W::PE11 => 4,
EXTI11W::PA11 => 0,
EXTI11W::PB11 => 1,
EXTI11W::PC11 => 2,
EXTI11W::PD11 => 3,
EXTI11W::PF11 => 5,
}
}
}
#[doc = r"Proxy"]
pub struct _EXTI11W<'a> {
w: &'a mut W,
}
impl<'a> _EXTI11W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTI11W) -> &'a mut W {
unsafe { self.bits(variant._bits()) }
}
#[doc = "Select PE11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pe11(self) -> &'a mut W {
self.variant(EXTI11W::PE11)
}
#[doc = "Select PA11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pa11(self) -> &'a mut W {
self.variant(EXTI11W::PA11)
}
#[doc = "Select PB11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pb11(self) -> &'a mut W {
self.variant(EXTI11W::PB11)
}
#[doc = "Select PC11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pc11(self) -> &'a mut W {
self.variant(EXTI11W::PC11)
}
#[doc = "Select PD11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pd11(self) -> &'a mut W {
self.variant(EXTI11W::PD11)
}
#[doc = "Select PF11 as the source input for the EXTI11 external interrupt"]
#[inline(always)]
pub fn pf11(self) -> &'a mut W {
self.variant(EXTI11W::PF11)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x0f << 12);
self.w.bits |= ((value as u32) & 0x0f) << 12;
self.w
}
}
#[doc = "Possible values of the field `EXTI10`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI10R {
#[doc = "Select PE10 as the source input for the EXTI10 external interrupt"]
PE10,
#[doc = "Select PA10 as the source input for the EXTI10 external interrupt"]
PA10,
#[doc = "Select PB10 as the source input for the EXTI10 external interrupt"]
PB10,
#[doc = "Select PC10 as the source input for the EXTI10 external interrupt"]
PC10,
#[doc = "Select PD10 as the source input for the EXTI10 external interrupt"]
PD10,
#[doc = "Select PF10 as the source input for the EXTI10 external interrupt"]
PF10,
#[doc = r"Reserved"]
_Reserved(u8),
}
impl EXTI10R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
EXTI10R::PE10 => 0x04,
EXTI10R::PA10 => 0,
EXTI10R::PB10 => 0x01,
EXTI10R::PC10 => 0x02,
EXTI10R::PD10 => 0x03,
EXTI10R::PF10 => 0x05,
EXTI10R::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> EXTI10R {
match value {
4 => EXTI10R::PE10,
0 => EXTI10R::PA10,
1 => EXTI10R::PB10,
2 => EXTI10R::PC10,
3 => EXTI10R::PD10,
5 => EXTI10R::PF10,
i => EXTI10R::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `PE10`"]
#[inline(always)]
pub fn is_pe10(&self) -> bool {
*self == EXTI10R::PE10
}
#[doc = "Checks if the value of the field is `PA10`"]
#[inline(always)]
pub fn is_pa10(&self) -> bool {
*self == EXTI10R::PA10
}
#[doc = "Checks if the value of the field is `PB10`"]
#[inline(always)]
pub fn is_pb10(&self) -> bool {
*self == EXTI10R::PB10
}
#[doc = "Checks if the value of the field is `PC10`"]
#[inline(always)]
pub fn is_pc10(&self) -> bool {
*self == EXTI10R::PC10
}
#[doc = "Checks if the value of the field is `PD10`"]
#[inline(always)]
pub fn is_pd10(&self) -> bool {
*self == EXTI10R::PD10
}
#[doc = "Checks if the value of the field is `PF10`"]
#[inline(always)]
pub fn is_pf10(&self) -> bool {
*self == EXTI10R::PF10
}
}
#[doc = "Values that can be written to the field `EXTI10`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI10W {
#[doc = "Select PE10 as the source input for the EXTI10 external interrupt"]
PE10,
#[doc = "Select PA10 as the source input for the EXTI10 external interrupt"]
PA10,
#[doc = "Select PB10 as the source input for the EXTI10 external interrupt"]
PB10,
#[doc = "Select PC10 as the source input for the EXTI10 external interrupt"]
PC10,
#[doc = "Select PD10 as the source input for the EXTI10 external interrupt"]
PD10,
#[doc = "Select PF10 as the source input for the EXTI10 external interrupt"]
PF10,
}
impl EXTI10W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
EXTI10W::PE10 => 4,
EXTI10W::PA10 => 0,
EXTI10W::PB10 => 1,
EXTI10W::PC10 => 2,
EXTI10W::PD10 => 3,
EXTI10W::PF10 => 5,
}
}
}
#[doc = r"Proxy"]
pub struct _EXTI10W<'a> {
w: &'a mut W,
}
impl<'a> _EXTI10W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTI10W) -> &'a mut W {
unsafe { self.bits(variant._bits()) }
}
#[doc = "Select PE10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pe10(self) -> &'a mut W {
self.variant(EXTI10W::PE10)
}
#[doc = "Select PA10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pa10(self) -> &'a mut W {
self.variant(EXTI10W::PA10)
}
#[doc = "Select PB10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pb10(self) -> &'a mut W {
self.variant(EXTI10W::PB10)
}
#[doc = "Select PC10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pc10(self) -> &'a mut W {
self.variant(EXTI10W::PC10)
}
#[doc = "Select PD10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pd10(self) -> &'a mut W {
self.variant(EXTI10W::PD10)
}
#[doc = "Select PF10 as the source input for the EXTI10 external interrupt"]
#[inline(always)]
pub fn pf10(self) -> &'a mut W {
self.variant(EXTI10W::PF10)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x0f << 8);
self.w.bits |= ((value as u32) & 0x0f) << 8;
self.w
}
}
#[doc = "Possible values of the field `EXTI9`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI9R {
#[doc = "Select PE9 as the source input for the EXTI9 external interrupt"]
PE9,
#[doc = "Select PA9 as the source input for the EXTI9 external interrupt"]
PA9,
#[doc = "Select PB9 as the source input for the EXTI9 external interrupt"]
PB9,
#[doc = "Select PC9 as the source input for the EXTI9 external interrupt"]
PC9,
#[doc = "Select PD9 as the source input for the EXTI9 external interrupt"]
PD9,
#[doc = "Select PF9 as the source input for the EXTI9 external interrupt"]
PF9,
#[doc = r"Reserved"]
_Reserved(u8),
}
impl EXTI9R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
EXTI9R::PE9 => 0x04,
EXTI9R::PA9 => 0,
EXTI9R::PB9 => 0x01,
EXTI9R::PC9 => 0x02,
EXTI9R::PD9 => 0x03,
EXTI9R::PF9 => 0x05,
EXTI9R::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> EXTI9R {
match value {
4 => EXTI9R::PE9,
0 => EXTI9R::PA9,
1 => EXTI9R::PB9,
2 => EXTI9R::PC9,
3 => EXTI9R::PD9,
5 => EXTI9R::PF9,
i => EXTI9R::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `PE9`"]
#[inline(always)]
pub fn is_pe9(&self) -> bool {
*self == EXTI9R::PE9
}
#[doc = "Checks if the value of the field is `PA9`"]
#[inline(always)]
pub fn is_pa9(&self) -> bool {
*self == EXTI9R::PA9
}
#[doc = "Checks if the value of the field is `PB9`"]
#[inline(always)]
pub fn is_pb9(&self) -> bool {
*self == EXTI9R::PB9
}
#[doc = "Checks if the value of the field is `PC9`"]
#[inline(always)]
pub fn is_pc9(&self) -> bool {
*self == EXTI9R::PC9
}
#[doc = "Checks if the value of the field is `PD9`"]
#[inline(always)]
pub fn is_pd9(&self) -> bool {
*self == EXTI9R::PD9
}
#[doc = "Checks if the value of the field is `PF9`"]
#[inline(always)]
pub fn is_pf9(&self) -> bool {
*self == EXTI9R::PF9
}
}
#[doc = "Values that can be written to the field `EXTI9`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI9W {
#[doc = "Select PE9 as the source input for the EXTI9 external interrupt"]
PE9,
#[doc = "Select PA9 as the source input for the EXTI9 external interrupt"]
PA9,
#[doc = "Select PB9 as the source input for the EXTI9 external interrupt"]
PB9,
#[doc = "Select PC9 as the source input for the EXTI9 external interrupt"]
PC9,
#[doc = "Select PD9 as the source input for the EXTI9 external interrupt"]
PD9,
#[doc = "Select PF9 as the source input for the EXTI9 external interrupt"]
PF9,
}
impl EXTI9W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
EXTI9W::PE9 => 4,
EXTI9W::PA9 => 0,
EXTI9W::PB9 => 1,
EXTI9W::PC9 => 2,
EXTI9W::PD9 => 3,
EXTI9W::PF9 => 5,
}
}
}
#[doc = r"Proxy"]
pub struct _EXTI9W<'a> {
w: &'a mut W,
}
impl<'a> _EXTI9W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTI9W) -> &'a mut W {
unsafe { self.bits(variant._bits()) }
}
#[doc = "Select PE9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pe9(self) -> &'a mut W {
self.variant(EXTI9W::PE9)
}
#[doc = "Select PA9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pa9(self) -> &'a mut W {
self.variant(EXTI9W::PA9)
}
#[doc = "Select PB9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pb9(self) -> &'a mut W {
self.variant(EXTI9W::PB9)
}
#[doc = "Select PC9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pc9(self) -> &'a mut W {
self.variant(EXTI9W::PC9)
}
#[doc = "Select PD9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pd9(self) -> &'a mut W {
self.variant(EXTI9W::PD9)
}
#[doc = "Select PF9 as the source input for the EXTI9 external interrupt"]
#[inline(always)]
pub fn pf9(self) -> &'a mut W {
self.variant(EXTI9W::PF9)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x0f << 4);
self.w.bits |= ((value as u32) & 0x0f) << 4;
self.w
}
}
#[doc = "Possible values of the field `EXTI8`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI8R {
#[doc = "Select PE8 as the source input for the EXTI8 external interrupt"]
PE8,
#[doc = "Select PA8 as the source input for the EXTI8 external interrupt"]
PA8,
#[doc = "Select PB8 as the source input for the EXTI8 external interrupt"]
PB8,
#[doc = "Select PC8 as the source input for the EXTI8 external interrupt"]
PC8,
#[doc = "Select PD8 as the source input for the EXTI8 external interrupt"]
PD8,
#[doc = "Select PF8 as the source input for the EXTI8 external interrupt"]
PF8,
#[doc = r"Reserved"]
_Reserved(u8),
}
impl EXTI8R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
EXTI8R::PE8 => 0x04,
EXTI8R::PA8 => 0,
EXTI8R::PB8 => 0x01,
EXTI8R::PC8 => 0x02,
EXTI8R::PD8 => 0x03,
EXTI8R::PF8 => 0x05,
EXTI8R::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> EXTI8R {
match value {
4 => EXTI8R::PE8,
0 => EXTI8R::PA8,
1 => EXTI8R::PB8,
2 => EXTI8R::PC8,
3 => EXTI8R::PD8,
5 => EXTI8R::PF8,
i => EXTI8R::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `PE8`"]
#[inline(always)]
pub fn is_pe8(&self) -> bool {
*self == EXTI8R::PE8
}
#[doc = "Checks if the value of the field is `PA8`"]
#[inline(always)]
pub fn is_pa8(&self) -> bool {
*self == EXTI8R::PA8
}
#[doc = "Checks if the value of the field is `PB8`"]
#[inline(always)]
pub fn is_pb8(&self) -> bool {
*self == EXTI8R::PB8
}
#[doc = "Checks if the value of the field is `PC8`"]
#[inline(always)]
pub fn is_pc8(&self) -> bool {
*self == EXTI8R::PC8
}
#[doc = "Checks if the value of the field is `PD8`"]
#[inline(always)]
pub fn is_pd8(&self) -> bool {
*self == EXTI8R::PD8
}
#[doc = "Checks if the value of the field is `PF8`"]
#[inline(always)]
pub fn is_pf8(&self) -> bool {
*self == EXTI8R::PF8
}
}
#[doc = "Values that can be written to the field `EXTI8`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI8W {
#[doc = "Select PE8 as the source input for the EXTI8 external interrupt"]
PE8,
#[doc = "Select PA8 as the source input for the EXTI8 external interrupt"]
PA8,
#[doc = "Select PB8 as the source input for the EXTI8 external interrupt"]
PB8,
#[doc = "Select PC8 as the source input for the EXTI8 external interrupt"]
PC8,
#[doc = "Select PD8 as the source input for the EXTI8 external interrupt"]
PD8,
#[doc = "Select PF8 as the source input for the EXTI8 external interrupt"]
PF8,
}
impl EXTI8W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
EXTI8W::PE8 => 4,
EXTI8W::PA8 => 0,
EXTI8W::PB8 => 1,
EXTI8W::PC8 => 2,
EXTI8W::PD8 => 3,
EXTI8W::PF8 => 5,
}
}
}
#[doc = r"Proxy"]
pub struct _EXTI8W<'a> {
w: &'a mut W,
}
impl<'a> _EXTI8W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTI8W) -> &'a mut W {
unsafe { self.bits(variant._bits()) }
}
#[doc = "Select PE8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pe8(self) -> &'a mut W {
self.variant(EXTI8W::PE8)
}
#[doc = "Select PA8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pa8(self) -> &'a mut W {
self.variant(EXTI8W::PA8)
}
#[doc = "Select PB8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pb8(self) -> &'a mut W {
self.variant(EXTI8W::PB8)
}
#[doc = "Select PC8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pc8(self) -> &'a mut W {
self.variant(EXTI8W::PC8)
}
#[doc = "Select PD8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pd8(self) -> &'a mut W {
self.variant(EXTI8W::PD8)
}
#[doc = "Select PF8 as the source input for the EXTI8 external interrupt"]
#[inline(always)]
pub fn pf8(self) -> &'a mut W {
self.variant(EXTI8W::PF8)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x0f << 0);
self.w.bits |= ((value as u32) & 0x0f) << 0;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 12:15 - EXTI 11 configuration bits"]
#[inline(always)]
pub fn exti11(&self) -> EXTI11R {
EXTI11R::_from(((self.bits >> 12) & 0x0f) as u8)
}
#[doc = "Bits 8:11 - EXTI 10 configuration bits"]
#[inline(always)]
pub fn exti10(&self) -> EXTI10R {
EXTI10R::_from(((self.bits >> 8) & 0x0f) as u8)
}
#[doc = "Bits 4:7 - EXTI 9 configuration bits"]
#[inline(always)]
pub fn exti9(&self) -> EXTI9R {
EXTI9R::_from(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 0:3 - EXTI 8 configuration bits"]
#[inline(always)]
pub fn exti8(&self) -> EXTI8R {
EXTI8R::_from(((self.bits >> 0) & 0x0f) as u8)
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bits 12:15 - EXTI 11 configuration bits"]
#[inline(always)]
pub fn exti11(&mut self) -> _EXTI11W {
_EXTI11W { w: self }
}
#[doc = "Bits 8:11 - EXTI 10 configuration bits"]
#[inline(always)]
pub fn exti10(&mut self) -> _EXTI10W {
_EXTI10W { w: self }
}
#[doc = "Bits 4:7 - EXTI 9 configuration bits"]
#[inline(always)]
pub fn exti9(&mut self) -> _EXTI9W {
_EXTI9W { w: self }
}
#[doc = "Bits 0:3 - EXTI 8 configuration bits"]
#[inline(always)]
pub fn exti8(&mut self) -> _EXTI8W {
_EXTI8W { w: self }
}
}