First building PAC version

Generated a first building version of the PAC. The PAC was generated with a specially patched version of svd2rust 0.19.0: https://github.com/robamu/svd2rust/tree/mueller/develop
2021-11-01 23:31:51 +01:00
parent 45d12c83bb
commit e97cd64ba6
200 changed files with 25316 additions and 9084 deletions
--- a/src/irqsel/edbgrq.rs
+++ b/src/irqsel/edbgrq.rs
@ -0,0 +1,53 @@
+#[doc = "Register `EDBGRQ` reader"]
+pub struct R(crate::R<EDBGRQ_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EDBGRQ_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EDBGRQ_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EDBGRQ_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "EDBGRQ Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [edbgrq](index.html) module"]
+pub struct EDBGRQ_SPEC;
+impl crate::RegisterSpec for EDBGRQ_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [edbgrq::R](R) reader structure"]
+impl crate::Readable for EDBGRQ_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets EDBGRQ to value 0"]
+impl crate::Resettable for EDBGRQ_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}
--- a/src/irqsel/i2c_ms.rs
+++ b/src/irqsel/i2c_ms.rs
@ -0,0 +1,65 @@
+#[doc = "Register `I2C_MS[%s]` reader"]
+pub struct R(crate::R<I2C_MS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<I2C_MS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<I2C_MS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<I2C_MS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `I2C_MS[%s]` writer"]
+pub struct W(crate::W<I2C_MS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<I2C_MS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<I2C_MS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<I2C_MS_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Master I2C Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [i2c_ms](index.html) module"]
+pub struct I2C_MS_SPEC;
+impl crate::RegisterSpec for I2C_MS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [i2c_ms::R](R) reader structure"]
+impl crate::Readable for I2C_MS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [i2c_ms::W](W) writer structure"]
+impl crate::Writable for I2C_MS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets I2C_MS[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for I2C_MS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/i2c_sl.rs
+++ b/src/irqsel/i2c_sl.rs
@ -0,0 +1,65 @@
+#[doc = "Register `I2C_SL[%s]` reader"]
+pub struct R(crate::R<I2C_SL_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<I2C_SL_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<I2C_SL_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<I2C_SL_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `I2C_SL[%s]` writer"]
+pub struct W(crate::W<I2C_SL_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<I2C_SL_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<I2C_SL_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<I2C_SL_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Slave I2C Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [i2c_sl](index.html) module"]
+pub struct I2C_SL_SPEC;
+impl crate::RegisterSpec for I2C_SL_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [i2c_sl::R](R) reader structure"]
+impl crate::Readable for I2C_SL_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [i2c_sl::W](W) writer structure"]
+impl crate::Writable for I2C_SL_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets I2C_SL[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for I2C_SL_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/int_ram_mbe.rs
+++ b/src/irqsel/int_ram_mbe.rs
@ -0,0 +1,64 @@
+#[doc = "Register `INT_RAM_MBE` reader"]
+pub struct R(crate::R<INT_RAM_MBE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INT_RAM_MBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INT_RAM_MBE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INT_RAM_MBE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INT_RAM_MBE` writer"]
+pub struct W(crate::W<INT_RAM_MBE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INT_RAM_MBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INT_RAM_MBE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INT_RAM_MBE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Internal Memory RAM MBE Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [int_ram_mbe](index.html) module"]
+pub struct INT_RAM_MBE_SPEC;
+impl crate::RegisterSpec for INT_RAM_MBE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [int_ram_mbe::R](R) reader structure"]
+impl crate::Readable for INT_RAM_MBE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [int_ram_mbe::W](W) writer structure"]
+impl crate::Writable for INT_RAM_MBE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INT_RAM_MBE to value 0xffff_ffff"]
+impl crate::Resettable for INT_RAM_MBE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/int_ram_sbe.rs
+++ b/src/irqsel/int_ram_sbe.rs
@ -0,0 +1,64 @@
+#[doc = "Register `INT_RAM_SBE` reader"]
+pub struct R(crate::R<INT_RAM_SBE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INT_RAM_SBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INT_RAM_SBE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INT_RAM_SBE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INT_RAM_SBE` writer"]
+pub struct W(crate::W<INT_RAM_SBE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INT_RAM_SBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INT_RAM_SBE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INT_RAM_SBE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Internal Memory RAM SBE Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [int_ram_sbe](index.html) module"]
+pub struct INT_RAM_SBE_SPEC;
+impl crate::RegisterSpec for INT_RAM_SBE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [int_ram_sbe::R](R) reader structure"]
+impl crate::Readable for INT_RAM_SBE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [int_ram_sbe::W](W) writer structure"]
+impl crate::Writable for INT_RAM_SBE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INT_RAM_SBE to value 0xffff_ffff"]
+impl crate::Resettable for INT_RAM_SBE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/int_rom_mbe.rs
+++ b/src/irqsel/int_rom_mbe.rs
@ -0,0 +1,64 @@
+#[doc = "Register `INT_ROM_MBE` reader"]
+pub struct R(crate::R<INT_ROM_MBE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INT_ROM_MBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INT_ROM_MBE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INT_ROM_MBE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INT_ROM_MBE` writer"]
+pub struct W(crate::W<INT_ROM_MBE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INT_ROM_MBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INT_ROM_MBE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INT_ROM_MBE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Internal Memory ROM MBE Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [int_rom_mbe](index.html) module"]
+pub struct INT_ROM_MBE_SPEC;
+impl crate::RegisterSpec for INT_ROM_MBE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [int_rom_mbe::R](R) reader structure"]
+impl crate::Readable for INT_ROM_MBE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [int_rom_mbe::W](W) writer structure"]
+impl crate::Writable for INT_ROM_MBE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INT_ROM_MBE to value 0xffff_ffff"]
+impl crate::Resettable for INT_ROM_MBE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/int_rom_sbe.rs
+++ b/src/irqsel/int_rom_sbe.rs
@ -0,0 +1,64 @@
+#[doc = "Register `INT_ROM_SBE` reader"]
+pub struct R(crate::R<INT_ROM_SBE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INT_ROM_SBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INT_ROM_SBE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INT_ROM_SBE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INT_ROM_SBE` writer"]
+pub struct W(crate::W<INT_ROM_SBE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INT_ROM_SBE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<INT_ROM_SBE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INT_ROM_SBE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Internal Memory ROM SBE Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [int_rom_sbe](index.html) module"]
+pub struct INT_ROM_SBE_SPEC;
+impl crate::RegisterSpec for INT_ROM_SBE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [int_rom_sbe::R](R) reader structure"]
+impl crate::Readable for INT_ROM_SBE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [int_rom_sbe::W](W) writer structure"]
+impl crate::Writable for INT_ROM_SBE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INT_ROM_SBE to value 0xffff_ffff"]
+impl crate::Resettable for INT_ROM_SBE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/irqs.rs
+++ b/src/irqsel/irqs.rs
@ -0,0 +1,54 @@
+#[doc = "Register `IRQS[%s]` reader"]
+pub struct R(crate::R<IRQS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<IRQS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<IRQS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<IRQS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "Interrupt Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irqs](index.html) module"]
+pub struct IRQS_SPEC;
+impl crate::RegisterSpec for IRQS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [irqs::R](R) reader structure"]
+impl crate::Readable for IRQS_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets IRQS[%s]
+to value 0"]
+impl crate::Resettable for IRQS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}
--- a/src/irqsel/mereset.rs
+++ b/src/irqsel/mereset.rs
@ -0,0 +1,53 @@
+#[doc = "Register `MERESET` reader"]
+pub struct R(crate::R<MERESET_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<MERESET_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<MERESET_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<MERESET_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "MERESET Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [mereset](index.html) module"]
+pub struct MERESET_SPEC;
+impl crate::RegisterSpec for MERESET_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [mereset::R](R) reader structure"]
+impl crate::Readable for MERESET_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets MERESET to value 0"]
+impl crate::Resettable for MERESET_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}
--- a/src/irqsel/nmi.rs
+++ b/src/irqsel/nmi.rs
@ -0,0 +1,53 @@
+#[doc = "Register `NMI` reader"]
+pub struct R(crate::R<NMI_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<NMI_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<NMI_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<NMI_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "NMI Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [nmi](index.html) module"]
+pub struct NMI_SPEC;
+impl crate::RegisterSpec for NMI_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [nmi::R](R) reader structure"]
+impl crate::Readable for NMI_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets NMI to value 0"]
+impl crate::Resettable for NMI_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}
--- a/src/irqsel/perid.rs
+++ b/src/irqsel/perid.rs
@ -0,0 +1,31 @@
+#[doc = "Register `PERID` reader"]
+pub struct R(crate::R<PERID_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PERID_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PERID_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PERID_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Peripheral ID Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [perid](index.html) module"]
+pub struct PERID_SPEC;
+impl crate::RegisterSpec for PERID_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [perid::R](R) reader structure"]
+impl crate::Readable for PERID_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets PERID to value 0x0080_07e1"]
+impl crate::Resettable for PERID_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0080_07e1
+    }
+}
--- a/src/irqsel/porta.rs
+++ b/src/irqsel/porta.rs
@ -0,0 +1,65 @@
+#[doc = "Register `PORTA[%s]` reader"]
+pub struct R(crate::R<PORTA_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PORTA_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PORTA_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PORTA_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PORTA[%s]` writer"]
+pub struct W(crate::W<PORTA_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PORTA_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<PORTA_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PORTA_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "PORTA Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [porta](index.html) module"]
+pub struct PORTA_SPEC;
+impl crate::RegisterSpec for PORTA_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [porta::R](R) reader structure"]
+impl crate::Readable for PORTA_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [porta::W](W) writer structure"]
+impl crate::Writable for PORTA_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PORTA[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for PORTA_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/portb.rs
+++ b/src/irqsel/portb.rs
@ -0,0 +1,65 @@
+#[doc = "Register `PORTB[%s]` reader"]
+pub struct R(crate::R<PORTB_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PORTB_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PORTB_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PORTB_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PORTB[%s]` writer"]
+pub struct W(crate::W<PORTB_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PORTB_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<PORTB_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PORTB_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "PORTB Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [portb](index.html) module"]
+pub struct PORTB_SPEC;
+impl crate::RegisterSpec for PORTB_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [portb::R](R) reader structure"]
+impl crate::Readable for PORTB_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [portb::W](W) writer structure"]
+impl crate::Writable for PORTB_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PORTB[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for PORTB_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/rxev.rs
+++ b/src/irqsel/rxev.rs
@ -0,0 +1,53 @@
+#[doc = "Register `RXEV` reader"]
+pub struct R(crate::R<RXEV_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<RXEV_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<RXEV_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<RXEV_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "RXEV Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rxev](index.html) module"]
+pub struct RXEV_SPEC;
+impl crate::RegisterSpec for RXEV_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [rxev::R](R) reader structure"]
+impl crate::Readable for RXEV_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets RXEV to value 0"]
+impl crate::Resettable for RXEV_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}
--- a/src/irqsel/spi.rs
+++ b/src/irqsel/spi.rs
@ -0,0 +1,65 @@
+#[doc = "Register `SPI[%s]` reader"]
+pub struct R(crate::R<SPI_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<SPI_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<SPI_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<SPI_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `SPI[%s]` writer"]
+pub struct W(crate::W<SPI_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SPI_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<SPI_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SPI_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "SPI Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [spi](index.html) module"]
+pub struct SPI_SPEC;
+impl crate::RegisterSpec for SPI_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [spi::R](R) reader structure"]
+impl crate::Readable for SPI_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [spi::W](W) writer structure"]
+impl crate::Writable for SPI_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets SPI[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for SPI_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/tim.rs
+++ b/src/irqsel/tim.rs
@ -0,0 +1,65 @@
+#[doc = "Register `TIM[%s]` reader"]
+pub struct R(crate::R<TIM_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<TIM_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<TIM_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<TIM_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `TIM[%s]` writer"]
+pub struct W(crate::W<TIM_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TIM_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<TIM_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TIM_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "TIM Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tim](index.html) module"]
+pub struct TIM_SPEC;
+impl crate::RegisterSpec for TIM_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [tim::R](R) reader structure"]
+impl crate::Readable for TIM_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [tim::W](W) writer structure"]
+impl crate::Writable for TIM_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TIM[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for TIM_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/txev.rs
+++ b/src/irqsel/txev.rs
@ -0,0 +1,64 @@
+#[doc = "Register `TXEV` reader"]
+pub struct R(crate::R<TXEV_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<TXEV_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<TXEV_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<TXEV_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `TXEV` writer"]
+pub struct W(crate::W<TXEV_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TXEV_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<TXEV_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TXEV_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "Processor TXEV Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txev](index.html) module"]
+pub struct TXEV_SPEC;
+impl crate::RegisterSpec for TXEV_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [txev::R](R) reader structure"]
+impl crate::Readable for TXEV_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [txev::W](W) writer structure"]
+impl crate::Writable for TXEV_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TXEV to value 0xffff_ffff"]
+impl crate::Resettable for TXEV_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/uart.rs
+++ b/src/irqsel/uart.rs
@ -0,0 +1,65 @@
+#[doc = "Register `UART[%s]` reader"]
+pub struct R(crate::R<UART_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<UART_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<UART_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<UART_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `UART[%s]` writer"]
+pub struct W(crate::W<UART_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<UART_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl core::ops::DerefMut for W {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+impl From<crate::W<UART_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<UART_SPEC>) -> Self {
+        W(writer)
+    }
+}
+impl W {
+    #[doc = "Writes raw bits to the register."]
+    #[inline(always)]
+    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
+        self.0.bits(bits);
+        self
+    }
+}
+#[doc = "UART Interrupt Redirect Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [uart](index.html) module"]
+pub struct UART_SPEC;
+impl crate::RegisterSpec for UART_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [uart::R](R) reader structure"]
+impl crate::Readable for UART_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [uart::W](W) writer structure"]
+impl crate::Writable for UART_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets UART[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for UART_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}
--- a/src/irqsel/watchdog.rs
+++ b/src/irqsel/watchdog.rs
@ -0,0 +1,53 @@
+#[doc = "Register `WATCHDOG` reader"]
+pub struct R(crate::R<WATCHDOG_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<WATCHDOG_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<WATCHDOG_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<WATCHDOG_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ACTIVE` reader - Active"]
+pub struct ACTIVE_R(crate::FieldReader<bool, bool>);
+impl ACTIVE_R {
+    #[inline(always)]
+    pub(crate) fn new(bits: bool) -> Self {
+        ACTIVE_R(crate::FieldReader::new(bits))
+    }
+}
+impl core::ops::Deref for ACTIVE_R {
+    type Target = crate::FieldReader<bool, bool>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Active"]
+    #[inline(always)]
+    pub fn active(&self) -> ACTIVE_R {
+        ACTIVE_R::new(self.bits != 0)
+    }
+}
+#[doc = "WATCHDOG Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [watchdog](index.html) module"]
+pub struct WATCHDOG_SPEC;
+impl crate::RegisterSpec for WATCHDOG_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [watchdog::R](R) reader structure"]
+impl crate::Readable for WATCHDOG_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets WATCHDOG to value 0"]
+impl crate::Resettable for WATCHDOG_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}