feat: add display UI with splash screen, dashboard, and RSSI sparkline
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
+16
@@ -0,0 +1,16 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct EVENTS_PREGION {
|
||||
#[doc = "0x00 - Description cluster\\[n\\]: Write access to peripheral region n detected"]
|
||||
pub wa: WA,
|
||||
#[doc = "0x04 - Description cluster\\[n\\]: Read access to peripheral region n detected"]
|
||||
pub ra: RA,
|
||||
}
|
||||
#[doc = "WA (rw) register accessor: an alias for `Reg<WA_SPEC>`"]
|
||||
pub type WA = crate::Reg<wa::WA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Write access to peripheral region n detected"]
|
||||
pub mod wa;
|
||||
#[doc = "RA (rw) register accessor: an alias for `Reg<RA_SPEC>`"]
|
||||
pub type RA = crate::Reg<ra::RA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Read access to peripheral region n detected"]
|
||||
pub mod ra;
|
||||
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `RA` reader"]
|
||||
pub struct R(crate::R<RA_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<RA_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<RA_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<RA_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `RA` writer"]
|
||||
pub struct W(crate::W<RA_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<RA_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<RA_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<RA_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RA` reader - "]
|
||||
pub type RA_R = crate::BitReader<bool>;
|
||||
#[doc = "Field `RA` writer - "]
|
||||
pub type RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, RA_SPEC, bool, O>;
|
||||
impl R {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn ra(&self) -> RA_R {
|
||||
RA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn ra(&mut self) -> RA_W<0> {
|
||||
RA_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: Read access to peripheral region n detected\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 [ra](index.html) module"]
|
||||
pub struct RA_SPEC;
|
||||
impl crate::RegisterSpec for RA_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ra::R](R) reader structure"]
|
||||
impl crate::Readable for RA_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ra::W](W) writer structure"]
|
||||
impl crate::Writable for RA_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets RA to value 0"]
|
||||
impl crate::Resettable for RA_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `WA` reader"]
|
||||
pub struct R(crate::R<WA_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<WA_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<WA_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<WA_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `WA` writer"]
|
||||
pub struct W(crate::W<WA_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<WA_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<WA_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<WA_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `WA` reader - "]
|
||||
pub type WA_R = crate::BitReader<bool>;
|
||||
#[doc = "Field `WA` writer - "]
|
||||
pub type WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, WA_SPEC, bool, O>;
|
||||
impl R {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn wa(&self) -> WA_R {
|
||||
WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn wa(&mut self) -> WA_W<0> {
|
||||
WA_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: Write access to peripheral region n detected\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 [wa](index.html) module"]
|
||||
pub struct WA_SPEC;
|
||||
impl crate::RegisterSpec for WA_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [wa::R](R) reader structure"]
|
||||
impl crate::Readable for WA_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [wa::W](W) writer structure"]
|
||||
impl crate::Writable for WA_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets WA to value 0"]
|
||||
impl crate::Resettable for WA_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct EVENTS_REGION {
|
||||
#[doc = "0x00 - Description cluster\\[n\\]: Write access to region n detected"]
|
||||
pub wa: WA,
|
||||
#[doc = "0x04 - Description cluster\\[n\\]: Read access to region n detected"]
|
||||
pub ra: RA,
|
||||
}
|
||||
#[doc = "WA (rw) register accessor: an alias for `Reg<WA_SPEC>`"]
|
||||
pub type WA = crate::Reg<wa::WA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Write access to region n detected"]
|
||||
pub mod wa;
|
||||
#[doc = "RA (rw) register accessor: an alias for `Reg<RA_SPEC>`"]
|
||||
pub type RA = crate::Reg<ra::RA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Read access to region n detected"]
|
||||
pub mod ra;
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `RA` reader"]
|
||||
pub struct R(crate::R<RA_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<RA_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<RA_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<RA_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `RA` writer"]
|
||||
pub struct W(crate::W<RA_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<RA_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<RA_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<RA_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RA` reader - "]
|
||||
pub type RA_R = crate::BitReader<bool>;
|
||||
#[doc = "Field `RA` writer - "]
|
||||
pub type RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, RA_SPEC, bool, O>;
|
||||
impl R {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn ra(&self) -> RA_R {
|
||||
RA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn ra(&mut self) -> RA_W<0> {
|
||||
RA_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: Read access to region n detected\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 [ra](index.html) module"]
|
||||
pub struct RA_SPEC;
|
||||
impl crate::RegisterSpec for RA_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [ra::R](R) reader structure"]
|
||||
impl crate::Readable for RA_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [ra::W](W) writer structure"]
|
||||
impl crate::Writable for RA_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets RA to value 0"]
|
||||
impl crate::Resettable for RA_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `WA` reader"]
|
||||
pub struct R(crate::R<WA_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<WA_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<WA_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<WA_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `WA` writer"]
|
||||
pub struct W(crate::W<WA_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<WA_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<WA_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<WA_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `WA` reader - "]
|
||||
pub type WA_R = crate::BitReader<bool>;
|
||||
#[doc = "Field `WA` writer - "]
|
||||
pub type WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, WA_SPEC, bool, O>;
|
||||
impl R {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn wa(&self) -> WA_R {
|
||||
WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0"]
|
||||
#[inline(always)]
|
||||
pub fn wa(&mut self) -> WA_W<0> {
|
||||
WA_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: Write access to region n detected\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 [wa](index.html) module"]
|
||||
pub struct WA_SPEC;
|
||||
impl crate::RegisterSpec for WA_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [wa::R](R) reader structure"]
|
||||
impl crate::Readable for WA_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [wa::W](W) writer structure"]
|
||||
impl crate::Writable for WA_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets WA to value 0"]
|
||||
impl crate::Resettable for WA_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
Vendored
+786
@@ -0,0 +1,786 @@
|
||||
#[doc = "Register `INTEN` reader"]
|
||||
pub struct R(crate::R<INTEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `INTEN` writer"]
|
||||
pub struct W(crate::W<INTEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<INTEN_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<INTEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<INTEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Enable or disable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Enable or disable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION0WA_A, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Enable or disable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Enable or disable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION0RA_A, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Enable or disable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Enable or disable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION1WA_A, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Enable or disable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Enable or disable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION1RA_A, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Enable or disable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Enable or disable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION2WA_A, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Enable or disable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Enable or disable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION2RA_A, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Enable or disable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Enable or disable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION3WA_A, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Enable or disable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Enable or disable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Enable or disable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, REGION3RA_A, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Enable or disable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Enable or disable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Enable or disable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, PREGION0WA_A, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Enable or disable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Enable or disable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Enable or disable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, PREGION0RA_A, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Enable or disable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Enable or disable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Enable or disable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, PREGION1WA_A, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Enable or disable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Enable or disable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Enable or disable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, PREGION1RA_A, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable or disable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable or disable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable or disable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable or disable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable or disable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable or disable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable or disable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable or disable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable or disable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable or disable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable or disable interrupt\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 [inten](index.html) module"]
|
||||
pub struct INTEN_SPEC;
|
||||
impl crate::RegisterSpec for INTEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [inten::R](R) reader structure"]
|
||||
impl crate::Readable for INTEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [inten::W](W) writer structure"]
|
||||
impl crate::Writable for INTEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets INTEN to value 0"]
|
||||
impl crate::Resettable for INTEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `INTENCLR` reader"]
|
||||
pub struct R(crate::R<INTENCLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTENCLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTENCLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `INTENCLR` writer"]
|
||||
pub struct W(crate::W<INTENCLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<INTENCLR_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<INTENCLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<INTENCLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Write '1' to disable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Write '1' to disable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Write '1' to disable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Write '1' to disable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Write '1' to disable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Write '1' to disable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Write '1' to disable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Write '1' to disable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Write '1' to disable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Write '1' to disable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION2WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Write '1' to disable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Write '1' to disable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION2RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Write '1' to disable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Write '1' to disable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION3WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Write '1' to disable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Write '1' to disable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, REGION3RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Write '1' to disable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Write '1' to disable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, PREGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Write '1' to disable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Write '1' to disable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, PREGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Write '1' to disable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Write '1' to disable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, PREGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Write '1' to disable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Write '1' to disable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, PREGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to disable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to disable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to disable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to disable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to disable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to disable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to disable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to disable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Disable interrupt\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 [intenclr](index.html) module"]
|
||||
pub struct INTENCLR_SPEC;
|
||||
impl crate::RegisterSpec for INTENCLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [intenclr::R](R) reader structure"]
|
||||
impl crate::Readable for INTENCLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [intenclr::W](W) writer structure"]
|
||||
impl crate::Writable for INTENCLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets INTENCLR to value 0"]
|
||||
impl crate::Resettable for INTENCLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `INTENSET` reader"]
|
||||
pub struct R(crate::R<INTENSET_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTENSET_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `INTENSET` writer"]
|
||||
pub struct W(crate::W<INTENSET_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<INTENSET_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<INTENSET_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Write '1' to enable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Write '1' to enable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Write '1' to enable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Write '1' to enable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Write '1' to enable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Write '1' to enable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Write '1' to enable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Write '1' to enable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Write '1' to enable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Write '1' to enable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION2WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Write '1' to enable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Write '1' to enable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION2RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Write '1' to enable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Write '1' to enable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION3WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Write '1' to enable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Write '1' to enable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, REGION3RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Write '1' to enable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Write '1' to enable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, PREGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Write '1' to enable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Write '1' to enable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, PREGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Write '1' to enable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Write '1' to enable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, PREGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Write '1' to enable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Write '1' to enable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, PREGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to enable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to enable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to enable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to enable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to enable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to enable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to enable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to enable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable interrupt\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 [intenset](index.html) module"]
|
||||
pub struct INTENSET_SPEC;
|
||||
impl crate::RegisterSpec for INTENSET_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [intenset::R](R) reader structure"]
|
||||
impl crate::Readable for INTENSET_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [intenset::W](W) writer structure"]
|
||||
impl crate::Writable for INTENSET_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets INTENSET to value 0"]
|
||||
impl crate::Resettable for INTENSET_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
Vendored
+786
@@ -0,0 +1,786 @@
|
||||
#[doc = "Register `NMIEN` reader"]
|
||||
pub struct R(crate::R<NMIEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<NMIEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<NMIEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<NMIEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `NMIEN` writer"]
|
||||
pub struct W(crate::W<NMIEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<NMIEN_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<NMIEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<NMIEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Enable or disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Enable or disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION0WA_A, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Enable or disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Enable or disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION0RA_A, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Enable or disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Enable or disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION1WA_A, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Enable or disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Enable or disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION1RA_A, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Enable or disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Enable or disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION2WA_A, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Enable or disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Enable or disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION2RA_A, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Enable or disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Enable or disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION3WA_A, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Enable or disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Enable or disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, REGION3RA_A, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Enable or disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Enable or disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, PREGION0WA_A, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Enable or disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Enable or disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, PREGION0RA_A, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Enable or disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Enable or disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, PREGION1WA_A, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Enable or disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Enable or disable non-maskable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Enable or disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIEN_SPEC, PREGION1RA_A, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable or disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable or disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable or disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable or disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable or disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable or disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable or disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable or disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable or disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable or disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable or disable non-maskable interrupt\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 [nmien](index.html) module"]
|
||||
pub struct NMIEN_SPEC;
|
||||
impl crate::RegisterSpec for NMIEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [nmien::R](R) reader structure"]
|
||||
impl crate::Readable for NMIEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [nmien::W](W) writer structure"]
|
||||
impl crate::Writable for NMIEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets NMIEN to value 0"]
|
||||
impl crate::Resettable for NMIEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `NMIENCLR` reader"]
|
||||
pub struct R(crate::R<NMIENCLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<NMIENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<NMIENCLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<NMIENCLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `NMIENCLR` writer"]
|
||||
pub struct W(crate::W<NMIENCLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<NMIENCLR_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<NMIENCLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<NMIENCLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION2WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION2RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION3WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<REGION3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, REGION3RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, PREGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, PREGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, PREGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PREGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENCLR_SPEC, PREGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to disable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to disable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to disable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Disable non-maskable interrupt\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 [nmienclr](index.html) module"]
|
||||
pub struct NMIENCLR_SPEC;
|
||||
impl crate::RegisterSpec for NMIENCLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [nmienclr::R](R) reader structure"]
|
||||
impl crate::Readable for NMIENCLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [nmienclr::W](W) writer structure"]
|
||||
impl crate::Writable for NMIENCLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets NMIENCLR to value 0"]
|
||||
impl crate::Resettable for NMIENCLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `NMIENSET` reader"]
|
||||
pub struct R(crate::R<NMIENSET_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<NMIENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<NMIENSET_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<NMIENSET_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `NMIENSET` writer"]
|
||||
pub struct W(crate::W<NMIENSET_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<NMIENSET_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<NMIENSET_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<NMIENSET_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` reader - Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_R = crate::BitReader<REGION0WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0WA_A {
|
||||
match self.bits {
|
||||
false => REGION0WA_A::DISABLED,
|
||||
true => REGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0WA` writer - Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
pub type REGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` reader - Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_R = crate::BitReader<REGION0RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION0RA_A {
|
||||
match self.bits {
|
||||
false => REGION0RA_A::DISABLED,
|
||||
true => REGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION0RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION0RA` writer - Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
pub type REGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION0RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` reader - Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_R = crate::BitReader<REGION1WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1WA_A {
|
||||
match self.bits {
|
||||
false => REGION1WA_A::DISABLED,
|
||||
true => REGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1WA` writer - Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
pub type REGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` reader - Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_R = crate::BitReader<REGION1RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION1RA_A {
|
||||
match self.bits {
|
||||
false => REGION1RA_A::DISABLED,
|
||||
true => REGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION1RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION1RA` writer - Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
pub type REGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION1RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` reader - Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_R = crate::BitReader<REGION2WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2WA_A {
|
||||
match self.bits {
|
||||
false => REGION2WA_A::DISABLED,
|
||||
true => REGION2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2WA` writer - Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
pub type REGION2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION2WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION2WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` reader - Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_R = crate::BitReader<REGION2RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION2RA_A {
|
||||
match self.bits {
|
||||
false => REGION2RA_A::DISABLED,
|
||||
true => REGION2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION2RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION2RA` writer - Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
pub type REGION2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION2RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION2RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION2RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` reader - Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_R = crate::BitReader<REGION3WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3WA_A {
|
||||
match self.bits {
|
||||
false => REGION3WA_A::DISABLED,
|
||||
true => REGION3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3WA` writer - Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
pub type REGION3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION3WA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION3WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` reader - Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_R = crate::BitReader<REGION3RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<REGION3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl REGION3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> REGION3RA_A {
|
||||
match self.bits {
|
||||
false => REGION3RA_A::DISABLED,
|
||||
true => REGION3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == REGION3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == REGION3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum REGION3RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<REGION3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: REGION3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `REGION3RA` writer - Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
pub type REGION3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, REGION3RA_AW, O>;
|
||||
impl<'a, const O: u8> REGION3RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(REGION3RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` reader - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_R = crate::BitReader<PREGION0WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0WA_A {
|
||||
match self.bits {
|
||||
false => PREGION0WA_A::DISABLED,
|
||||
true => PREGION0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0WA` writer - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
pub type PREGION0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, PREGION0WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` reader - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_R = crate::BitReader<PREGION0RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION0RA_A {
|
||||
match self.bits {
|
||||
false => PREGION0RA_A::DISABLED,
|
||||
true => PREGION0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION0RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION0RA` writer - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
pub type PREGION0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, PREGION0RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION0RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` reader - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_R = crate::BitReader<PREGION1WA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1WA_A {
|
||||
match self.bits {
|
||||
false => PREGION1WA_A::DISABLED,
|
||||
true => PREGION1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1WA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1WA` writer - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
pub type PREGION1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, PREGION1WA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1WA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` reader - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_R = crate::BitReader<PREGION1RA_A>;
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PREGION1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PREGION1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PREGION1RA_A {
|
||||
match self.bits {
|
||||
false => PREGION1RA_A::DISABLED,
|
||||
true => PREGION1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PREGION1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PREGION1RA_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PREGION1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PREGION1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PREGION1RA` writer - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
pub type PREGION1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, NMIENSET_SPEC, PREGION1RA_AW, O>;
|
||||
impl<'a, const O: u8> PREGION1RA_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PREGION1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&self) -> REGION0WA_R {
|
||||
REGION0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&self) -> REGION0RA_R {
|
||||
REGION0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&self) -> REGION1WA_R {
|
||||
REGION1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&self) -> REGION1RA_R {
|
||||
REGION1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&self) -> REGION2WA_R {
|
||||
REGION2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&self) -> REGION2RA_R {
|
||||
REGION2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&self) -> REGION3WA_R {
|
||||
REGION3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&self) -> REGION3RA_R {
|
||||
REGION3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&self) -> PREGION0WA_R {
|
||||
PREGION0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&self) -> PREGION0RA_R {
|
||||
PREGION0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&self) -> PREGION1WA_R {
|
||||
PREGION1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&self) -> PREGION1RA_R {
|
||||
PREGION1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to enable non-maskable interrupt for REGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0wa(&mut self) -> REGION0WA_W<0> {
|
||||
REGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable non-maskable interrupt for REGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region0ra(&mut self) -> REGION0RA_W<1> {
|
||||
REGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable non-maskable interrupt for REGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1wa(&mut self) -> REGION1WA_W<2> {
|
||||
REGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable non-maskable interrupt for REGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region1ra(&mut self) -> REGION1RA_W<3> {
|
||||
REGION1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable non-maskable interrupt for REGION\\[2\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2wa(&mut self) -> REGION2WA_W<4> {
|
||||
REGION2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable non-maskable interrupt for REGION\\[2\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region2ra(&mut self) -> REGION2RA_W<5> {
|
||||
REGION2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable non-maskable interrupt for REGION\\[3\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3wa(&mut self) -> REGION3WA_W<6> {
|
||||
REGION3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable non-maskable interrupt for REGION\\[3\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn region3ra(&mut self) -> REGION3RA_W<7> {
|
||||
REGION3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0wa(&mut self) -> PREGION0WA_W<24> {
|
||||
PREGION0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Write '1' to enable non-maskable interrupt for PREGION\\[0\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion0ra(&mut self) -> PREGION0RA_W<25> {
|
||||
PREGION0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].WA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1wa(&mut self) -> PREGION1WA_W<26> {
|
||||
PREGION1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Write '1' to enable non-maskable interrupt for PREGION\\[1\\].RA event"]
|
||||
#[inline(always)]
|
||||
pub fn pregion1ra(&mut self) -> PREGION1RA_W<27> {
|
||||
PREGION1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable non-maskable interrupt\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 [nmienset](index.html) module"]
|
||||
pub struct NMIENSET_SPEC;
|
||||
impl crate::RegisterSpec for NMIENSET_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [nmienset::R](R) reader structure"]
|
||||
impl crate::Readable for NMIENSET_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [nmienset::W](W) writer structure"]
|
||||
impl crate::Writable for NMIENSET_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets NMIENSET to value 0"]
|
||||
impl crate::Resettable for NMIENSET_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct PERREGION {
|
||||
#[doc = "0x00 - Description cluster\\[n\\]: Source of event/interrupt in region n, write access detected while corresponding subregion was enabled for watching"]
|
||||
pub substatwa: SUBSTATWA,
|
||||
#[doc = "0x04 - Description cluster\\[n\\]: Source of event/interrupt in region n, read access detected while corresponding subregion was enabled for watching"]
|
||||
pub substatra: SUBSTATRA,
|
||||
}
|
||||
#[doc = "SUBSTATWA (rw) register accessor: an alias for `Reg<SUBSTATWA_SPEC>`"]
|
||||
pub type SUBSTATWA = crate::Reg<substatwa::SUBSTATWA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Source of event/interrupt in region n, write access detected while corresponding subregion was enabled for watching"]
|
||||
pub mod substatwa;
|
||||
#[doc = "SUBSTATRA (rw) register accessor: an alias for `Reg<SUBSTATRA_SPEC>`"]
|
||||
pub type SUBSTATRA = crate::Reg<substatra::SUBSTATRA_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Source of event/interrupt in region n, read access detected while corresponding subregion was enabled for watching"]
|
||||
pub mod substatra;
|
||||
+1986
File diff suppressed because it is too large.
Load diff
+1986
File diff suppressed because it is too large.
Load diff
+22
@@ -0,0 +1,22 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct PREGION {
|
||||
#[doc = "0x00 - Description cluster\\[n\\]: Reserved for future use"]
|
||||
pub start: START,
|
||||
#[doc = "0x04 - Description cluster\\[n\\]: Reserved for future use"]
|
||||
pub end: END,
|
||||
#[doc = "0x08 - Description cluster\\[n\\]: Subregions of region n"]
|
||||
pub subs: SUBS,
|
||||
}
|
||||
#[doc = "START (r) register accessor: an alias for `Reg<START_SPEC>`"]
|
||||
pub type START = crate::Reg<start::START_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Reserved for future use"]
|
||||
pub mod start;
|
||||
#[doc = "END (r) register accessor: an alias for `Reg<END_SPEC>`"]
|
||||
pub type END = crate::Reg<end::END_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Reserved for future use"]
|
||||
pub mod end;
|
||||
#[doc = "SUBS (rw) register accessor: an alias for `Reg<SUBS_SPEC>`"]
|
||||
pub type SUBS = crate::Reg<subs::SUBS_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Subregions of region n"]
|
||||
pub mod subs;
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
#[doc = "Register `END` reader"]
|
||||
pub struct R(crate::R<END_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<END_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<END_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<END_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `END` reader - Reserved for future use"]
|
||||
pub type END_R = crate::FieldReader<u32, u32>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:31 - Reserved for future use"]
|
||||
#[inline(always)]
|
||||
pub fn end(&self) -> END_R {
|
||||
END_R::new(self.bits)
|
||||
}
|
||||
}
|
||||
#[doc = "Description cluster\\[n\\]: Reserved for future use\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 [end](index.html) module"]
|
||||
pub struct END_SPEC;
|
||||
impl crate::RegisterSpec for END_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [end::R](R) reader structure"]
|
||||
impl crate::Readable for END_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets END to value 0"]
|
||||
impl crate::Resettable for END_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
#[doc = "Register `START` reader"]
|
||||
pub struct R(crate::R<START_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<START_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<START_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<START_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `START` reader - Reserved for future use"]
|
||||
pub type START_R = crate::FieldReader<u32, u32>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:31 - Reserved for future use"]
|
||||
#[inline(always)]
|
||||
pub fn start(&self) -> START_R {
|
||||
START_R::new(self.bits)
|
||||
}
|
||||
}
|
||||
#[doc = "Description cluster\\[n\\]: Reserved for future use\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 [start](index.html) module"]
|
||||
pub struct START_SPEC;
|
||||
impl crate::RegisterSpec for START_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [start::R](R) reader structure"]
|
||||
impl crate::Readable for START_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets START to value 0"]
|
||||
impl crate::Resettable for START_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+1986
File diff suppressed because it is too large.
Load diff
+16
@@ -0,0 +1,16 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct REGION {
|
||||
#[doc = "0x00 - Description cluster\\[n\\]: Start address for region n"]
|
||||
pub start: START,
|
||||
#[doc = "0x04 - Description cluster\\[n\\]: End address of region n"]
|
||||
pub end: END,
|
||||
}
|
||||
#[doc = "START (rw) register accessor: an alias for `Reg<START_SPEC>`"]
|
||||
pub type START = crate::Reg<start::START_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: Start address for region n"]
|
||||
pub mod start;
|
||||
#[doc = "END (rw) register accessor: an alias for `Reg<END_SPEC>`"]
|
||||
pub type END = crate::Reg<end::END_SPEC>;
|
||||
#[doc = "Description cluster\\[n\\]: End address of region n"]
|
||||
pub mod end;
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `END` reader"]
|
||||
pub struct R(crate::R<END_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<END_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<END_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<END_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `END` writer"]
|
||||
pub struct W(crate::W<END_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<END_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<END_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<END_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `END` reader - End address of region."]
|
||||
pub type END_R = crate::FieldReader<u32, u32>;
|
||||
#[doc = "Field `END` writer - End address of region."]
|
||||
pub type END_W<'a, const O: u8> = crate::FieldWriter<'a, u32, END_SPEC, u32, u32, 32, O>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:31 - End address of region."]
|
||||
#[inline(always)]
|
||||
pub fn end(&self) -> END_R {
|
||||
END_R::new(self.bits)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:31 - End address of region."]
|
||||
#[inline(always)]
|
||||
pub fn end(&mut self) -> END_W<0> {
|
||||
END_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: End address of region n\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 [end](index.html) module"]
|
||||
pub struct END_SPEC;
|
||||
impl crate::RegisterSpec for END_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [end::R](R) reader structure"]
|
||||
impl crate::Readable for END_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [end::W](W) writer structure"]
|
||||
impl crate::Writable for END_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets END to value 0"]
|
||||
impl crate::Resettable for END_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
#[doc = "Register `START` reader"]
|
||||
pub struct R(crate::R<START_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<START_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<START_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<START_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `START` writer"]
|
||||
pub struct W(crate::W<START_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<START_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<START_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<START_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `START` reader - Start address for region"]
|
||||
pub type START_R = crate::FieldReader<u32, u32>;
|
||||
#[doc = "Field `START` writer - Start address for region"]
|
||||
pub type START_W<'a, const O: u8> = crate::FieldWriter<'a, u32, START_SPEC, u32, u32, 32, O>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:31 - Start address for region"]
|
||||
#[inline(always)]
|
||||
pub fn start(&self) -> START_R {
|
||||
START_R::new(self.bits)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:31 - Start address for region"]
|
||||
#[inline(always)]
|
||||
pub fn start(&mut self) -> START_W<0> {
|
||||
START_W::new(self)
|
||||
}
|
||||
#[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 = "Description cluster\\[n\\]: Start address for region n\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 [start](index.html) module"]
|
||||
pub struct START_SPEC;
|
||||
impl crate::RegisterSpec for START_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [start::R](R) reader structure"]
|
||||
impl crate::Readable for START_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [start::W](W) writer structure"]
|
||||
impl crate::Writable for START_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets START to value 0"]
|
||||
impl crate::Resettable for START_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+786
@@ -0,0 +1,786 @@
|
||||
#[doc = "Register `REGIONEN` reader"]
|
||||
pub struct R(crate::R<REGIONEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<REGIONEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<REGIONEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<REGIONEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `REGIONEN` writer"]
|
||||
pub struct W(crate::W<REGIONEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<REGIONEN_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<REGIONEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<REGIONEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` reader - Enable/disable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_R = crate::BitReader<RGN0WA_A>;
|
||||
#[doc = "Enable/disable write access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0WA_A {
|
||||
#[doc = "0: Disable write access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0WA_A {
|
||||
match self.bits {
|
||||
false => RGN0WA_A::DISABLE,
|
||||
true => RGN0WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN0WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN0WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` writer - Enable/disable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN0WA_A, O>;
|
||||
impl<'a, const O: u8> RGN0WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN0WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN0WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` reader - Enable/disable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_R = crate::BitReader<RGN0RA_A>;
|
||||
#[doc = "Enable/disable read access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0RA_A {
|
||||
#[doc = "0: Disable read access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0RA_A {
|
||||
match self.bits {
|
||||
false => RGN0RA_A::DISABLE,
|
||||
true => RGN0RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN0RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN0RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` writer - Enable/disable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN0RA_A, O>;
|
||||
impl<'a, const O: u8> RGN0RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN0RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN0RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` reader - Enable/disable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_R = crate::BitReader<RGN1WA_A>;
|
||||
#[doc = "Enable/disable write access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1WA_A {
|
||||
#[doc = "0: Disable write access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1WA_A {
|
||||
match self.bits {
|
||||
false => RGN1WA_A::DISABLE,
|
||||
true => RGN1WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN1WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN1WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` writer - Enable/disable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN1WA_A, O>;
|
||||
impl<'a, const O: u8> RGN1WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN1WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN1WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` reader - Enable/disable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_R = crate::BitReader<RGN1RA_A>;
|
||||
#[doc = "Enable/disable read access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1RA_A {
|
||||
#[doc = "0: Disable read access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1RA_A {
|
||||
match self.bits {
|
||||
false => RGN1RA_A::DISABLE,
|
||||
true => RGN1RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN1RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN1RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` writer - Enable/disable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN1RA_A, O>;
|
||||
impl<'a, const O: u8> RGN1RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN1RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN1RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` reader - Enable/disable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_R = crate::BitReader<RGN2WA_A>;
|
||||
#[doc = "Enable/disable write access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2WA_A {
|
||||
#[doc = "0: Disable write access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2WA_A {
|
||||
match self.bits {
|
||||
false => RGN2WA_A::DISABLE,
|
||||
true => RGN2WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN2WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN2WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` writer - Enable/disable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN2WA_A, O>;
|
||||
impl<'a, const O: u8> RGN2WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN2WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN2WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` reader - Enable/disable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_R = crate::BitReader<RGN2RA_A>;
|
||||
#[doc = "Enable/disable read access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2RA_A {
|
||||
#[doc = "0: Disable read access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2RA_A {
|
||||
match self.bits {
|
||||
false => RGN2RA_A::DISABLE,
|
||||
true => RGN2RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN2RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN2RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` writer - Enable/disable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN2RA_A, O>;
|
||||
impl<'a, const O: u8> RGN2RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN2RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN2RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` reader - Enable/disable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_R = crate::BitReader<RGN3WA_A>;
|
||||
#[doc = "Enable/disable write access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3WA_A {
|
||||
#[doc = "0: Disable write access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3WA_A {
|
||||
match self.bits {
|
||||
false => RGN3WA_A::DISABLE,
|
||||
true => RGN3WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN3WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN3WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` writer - Enable/disable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN3WA_A, O>;
|
||||
impl<'a, const O: u8> RGN3WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN3WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN3WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` reader - Enable/disable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_R = crate::BitReader<RGN3RA_A>;
|
||||
#[doc = "Enable/disable read access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3RA_A {
|
||||
#[doc = "0: Disable read access watch in this region"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<RGN3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3RA_A {
|
||||
match self.bits {
|
||||
false => RGN3RA_A::DISABLE,
|
||||
true => RGN3RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == RGN3RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == RGN3RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` writer - Enable/disable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, RGN3RA_A, O>;
|
||||
impl<'a, const O: u8> RGN3RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(RGN3RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(RGN3RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` reader - Enable/disable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_R = crate::BitReader<PRGN0WA_A>;
|
||||
#[doc = "Enable/disable write access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0WA_A {
|
||||
#[doc = "0: Disable write access watch in this PREGION"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this PREGION"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<PRGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0WA_A {
|
||||
match self.bits {
|
||||
false => PRGN0WA_A::DISABLE,
|
||||
true => PRGN0WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == PRGN0WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == PRGN0WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` writer - Enable/disable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, PRGN0WA_A, O>;
|
||||
impl<'a, const O: u8> PRGN0WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(PRGN0WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(PRGN0WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` reader - Enable/disable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_R = crate::BitReader<PRGN0RA_A>;
|
||||
#[doc = "Enable/disable read access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0RA_A {
|
||||
#[doc = "0: Disable read access watch in this PREGION"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this PREGION"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<PRGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0RA_A {
|
||||
match self.bits {
|
||||
false => PRGN0RA_A::DISABLE,
|
||||
true => PRGN0RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == PRGN0RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == PRGN0RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` writer - Enable/disable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, PRGN0RA_A, O>;
|
||||
impl<'a, const O: u8> PRGN0RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(PRGN0RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(PRGN0RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` reader - Enable/disable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_R = crate::BitReader<PRGN1WA_A>;
|
||||
#[doc = "Enable/disable write access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1WA_A {
|
||||
#[doc = "0: Disable write access watch in this PREGION"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable write access watch in this PREGION"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<PRGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1WA_A {
|
||||
match self.bits {
|
||||
false => PRGN1WA_A::DISABLE,
|
||||
true => PRGN1WA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == PRGN1WA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == PRGN1WA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` writer - Enable/disable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, PRGN1WA_A, O>;
|
||||
impl<'a, const O: u8> PRGN1WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(PRGN1WA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(PRGN1WA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` reader - Enable/disable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_R = crate::BitReader<PRGN1RA_A>;
|
||||
#[doc = "Enable/disable read access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1RA_A {
|
||||
#[doc = "0: Disable read access watch in this PREGION"]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable read access watch in this PREGION"]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<PRGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1RA_A {
|
||||
match self.bits {
|
||||
false => PRGN1RA_A::DISABLE,
|
||||
true => PRGN1RA_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == PRGN1RA_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == PRGN1RA_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` writer - Enable/disable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONEN_SPEC, PRGN1RA_A, O>;
|
||||
impl<'a, const O: u8> PRGN1RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(PRGN1RA_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(PRGN1RA_A::ENABLE)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable/disable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&self) -> RGN0WA_R {
|
||||
RGN0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable/disable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&self) -> RGN0RA_R {
|
||||
RGN0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable/disable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&self) -> RGN1WA_R {
|
||||
RGN1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable/disable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&self) -> RGN1RA_R {
|
||||
RGN1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable/disable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&self) -> RGN2WA_R {
|
||||
RGN2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable/disable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&self) -> RGN2RA_R {
|
||||
RGN2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable/disable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&self) -> RGN3WA_R {
|
||||
RGN3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable/disable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&self) -> RGN3RA_R {
|
||||
RGN3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable/disable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&self) -> PRGN0WA_R {
|
||||
PRGN0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable/disable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&self) -> PRGN0RA_R {
|
||||
PRGN0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable/disable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&self) -> PRGN1WA_R {
|
||||
PRGN1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable/disable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&self) -> PRGN1RA_R {
|
||||
PRGN1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable/disable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&mut self) -> RGN0WA_W<0> {
|
||||
RGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable/disable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&mut self) -> RGN0RA_W<1> {
|
||||
RGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable/disable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&mut self) -> RGN1WA_W<2> {
|
||||
RGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable/disable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&mut self) -> RGN1RA_W<3> {
|
||||
RGN1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable/disable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&mut self) -> RGN2WA_W<4> {
|
||||
RGN2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable/disable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&mut self) -> RGN2RA_W<5> {
|
||||
RGN2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable/disable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&mut self) -> RGN3WA_W<6> {
|
||||
RGN3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable/disable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&mut self) -> RGN3RA_W<7> {
|
||||
RGN3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable/disable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&mut self) -> PRGN0WA_W<24> {
|
||||
PRGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable/disable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&mut self) -> PRGN0RA_W<25> {
|
||||
PRGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable/disable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&mut self) -> PRGN1WA_W<26> {
|
||||
PRGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable/disable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&mut self) -> PRGN1RA_W<27> {
|
||||
PRGN1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable/disable regions watch\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 [regionen](index.html) module"]
|
||||
pub struct REGIONEN_SPEC;
|
||||
impl crate::RegisterSpec for REGIONEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [regionen::R](R) reader structure"]
|
||||
impl crate::Readable for REGIONEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [regionen::W](W) writer structure"]
|
||||
impl crate::Writable for REGIONEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets REGIONEN to value 0"]
|
||||
impl crate::Resettable for REGIONEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `REGIONENCLR` reader"]
|
||||
pub struct R(crate::R<REGIONENCLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<REGIONENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<REGIONENCLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<REGIONENCLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `REGIONENCLR` writer"]
|
||||
pub struct W(crate::W<REGIONENCLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<REGIONENCLR_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<REGIONENCLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<REGIONENCLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` reader - Disable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_R = crate::BitReader<RGN0WA_A>;
|
||||
#[doc = "Disable write access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0WA_A {
|
||||
match self.bits {
|
||||
false => RGN0WA_A::DISABLED,
|
||||
true => RGN0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0WA_AW {
|
||||
#[doc = "1: Disable write access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` writer - Disable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN0WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN0WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` reader - Disable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_R = crate::BitReader<RGN0RA_A>;
|
||||
#[doc = "Disable read access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0RA_A {
|
||||
match self.bits {
|
||||
false => RGN0RA_A::DISABLED,
|
||||
true => RGN0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0RA_AW {
|
||||
#[doc = "1: Disable read access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` writer - Disable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN0RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN0RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` reader - Disable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_R = crate::BitReader<RGN1WA_A>;
|
||||
#[doc = "Disable write access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1WA_A {
|
||||
match self.bits {
|
||||
false => RGN1WA_A::DISABLED,
|
||||
true => RGN1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1WA_AW {
|
||||
#[doc = "1: Disable write access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` writer - Disable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN1WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN1WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` reader - Disable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_R = crate::BitReader<RGN1RA_A>;
|
||||
#[doc = "Disable read access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1RA_A {
|
||||
match self.bits {
|
||||
false => RGN1RA_A::DISABLED,
|
||||
true => RGN1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1RA_AW {
|
||||
#[doc = "1: Disable read access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` writer - Disable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN1RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN1RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` reader - Disable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_R = crate::BitReader<RGN2WA_A>;
|
||||
#[doc = "Disable write access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2WA_A {
|
||||
match self.bits {
|
||||
false => RGN2WA_A::DISABLED,
|
||||
true => RGN2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2WA_AW {
|
||||
#[doc = "1: Disable write access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` writer - Disable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN2WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN2WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN2WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` reader - Disable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_R = crate::BitReader<RGN2RA_A>;
|
||||
#[doc = "Disable read access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2RA_A {
|
||||
match self.bits {
|
||||
false => RGN2RA_A::DISABLED,
|
||||
true => RGN2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2RA_AW {
|
||||
#[doc = "1: Disable read access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` writer - Disable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN2RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN2RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN2RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` reader - Disable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_R = crate::BitReader<RGN3WA_A>;
|
||||
#[doc = "Disable write access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3WA_A {
|
||||
match self.bits {
|
||||
false => RGN3WA_A::DISABLED,
|
||||
true => RGN3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3WA_AW {
|
||||
#[doc = "1: Disable write access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` writer - Disable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN3WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN3WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN3WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` reader - Disable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_R = crate::BitReader<RGN3RA_A>;
|
||||
#[doc = "Disable read access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3RA_A {
|
||||
match self.bits {
|
||||
false => RGN3RA_A::DISABLED,
|
||||
true => RGN3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3RA_AW {
|
||||
#[doc = "1: Disable read access watch in this region"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RGN3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` writer - Disable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, RGN3RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN3RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RGN3RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` reader - Disable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_R = crate::BitReader<PRGN0WA_A>;
|
||||
#[doc = "Disable write access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0WA_A {
|
||||
#[doc = "0: Write access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0WA_A {
|
||||
match self.bits {
|
||||
false => PRGN0WA_A::DISABLED,
|
||||
true => PRGN0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0WA_AW {
|
||||
#[doc = "1: Disable write access watch in this PREGION"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PRGN0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` writer - Disable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, PRGN0WA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN0WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PRGN0WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` reader - Disable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_R = crate::BitReader<PRGN0RA_A>;
|
||||
#[doc = "Disable read access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0RA_A {
|
||||
#[doc = "0: Read access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0RA_A {
|
||||
match self.bits {
|
||||
false => PRGN0RA_A::DISABLED,
|
||||
true => PRGN0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0RA_AW {
|
||||
#[doc = "1: Disable read access watch in this PREGION"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PRGN0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` writer - Disable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, PRGN0RA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN0RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PRGN0RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` reader - Disable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_R = crate::BitReader<PRGN1WA_A>;
|
||||
#[doc = "Disable write access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1WA_A {
|
||||
#[doc = "0: Write access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1WA_A {
|
||||
match self.bits {
|
||||
false => PRGN1WA_A::DISABLED,
|
||||
true => PRGN1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable write access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1WA_AW {
|
||||
#[doc = "1: Disable write access watch in this PREGION"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PRGN1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` writer - Disable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, PRGN1WA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN1WA_W<'a, O> {
|
||||
#[doc = "Disable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PRGN1WA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` reader - Disable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_R = crate::BitReader<PRGN1RA_A>;
|
||||
#[doc = "Disable read access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1RA_A {
|
||||
#[doc = "0: Read access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1RA_A {
|
||||
match self.bits {
|
||||
false => PRGN1RA_A::DISABLED,
|
||||
true => PRGN1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Disable read access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1RA_AW {
|
||||
#[doc = "1: Disable read access watch in this PREGION"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<PRGN1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` writer - Disable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENCLR_SPEC, PRGN1RA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN1RA_W<'a, O> {
|
||||
#[doc = "Disable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(PRGN1RA_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Disable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&self) -> RGN0WA_R {
|
||||
RGN0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Disable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&self) -> RGN0RA_R {
|
||||
RGN0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Disable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&self) -> RGN1WA_R {
|
||||
RGN1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Disable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&self) -> RGN1RA_R {
|
||||
RGN1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Disable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&self) -> RGN2WA_R {
|
||||
RGN2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Disable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&self) -> RGN2RA_R {
|
||||
RGN2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Disable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&self) -> RGN3WA_R {
|
||||
RGN3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Disable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&self) -> RGN3RA_R {
|
||||
RGN3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Disable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&self) -> PRGN0WA_R {
|
||||
PRGN0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Disable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&self) -> PRGN0RA_R {
|
||||
PRGN0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Disable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&self) -> PRGN1WA_R {
|
||||
PRGN1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Disable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&self) -> PRGN1RA_R {
|
||||
PRGN1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Disable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&mut self) -> RGN0WA_W<0> {
|
||||
RGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Disable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&mut self) -> RGN0RA_W<1> {
|
||||
RGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Disable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&mut self) -> RGN1WA_W<2> {
|
||||
RGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Disable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&mut self) -> RGN1RA_W<3> {
|
||||
RGN1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Disable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&mut self) -> RGN2WA_W<4> {
|
||||
RGN2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Disable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&mut self) -> RGN2RA_W<5> {
|
||||
RGN2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Disable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&mut self) -> RGN3WA_W<6> {
|
||||
RGN3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Disable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&mut self) -> RGN3RA_W<7> {
|
||||
RGN3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Disable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&mut self) -> PRGN0WA_W<24> {
|
||||
PRGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Disable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&mut self) -> PRGN0RA_W<25> {
|
||||
PRGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Disable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&mut self) -> PRGN1WA_W<26> {
|
||||
PRGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Disable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&mut self) -> PRGN1RA_W<27> {
|
||||
PRGN1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Disable regions watch\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 [regionenclr](index.html) module"]
|
||||
pub struct REGIONENCLR_SPEC;
|
||||
impl crate::RegisterSpec for REGIONENCLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [regionenclr::R](R) reader structure"]
|
||||
impl crate::Readable for REGIONENCLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [regionenclr::W](W) writer structure"]
|
||||
impl crate::Writable for REGIONENCLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets REGIONENCLR to value 0"]
|
||||
impl crate::Resettable for REGIONENCLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+870
@@ -0,0 +1,870 @@
|
||||
#[doc = "Register `REGIONENSET` reader"]
|
||||
pub struct R(crate::R<REGIONENSET_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<REGIONENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<REGIONENSET_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<REGIONENSET_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `REGIONENSET` writer"]
|
||||
pub struct W(crate::W<REGIONENSET_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<REGIONENSET_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<REGIONENSET_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<REGIONENSET_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` reader - Enable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_R = crate::BitReader<RGN0WA_A>;
|
||||
#[doc = "Enable write access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0WA_A {
|
||||
match self.bits {
|
||||
false => RGN0WA_A::DISABLED,
|
||||
true => RGN0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0WA_AW {
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0WA` writer - Enable write access watch in region\\[0\\]"]
|
||||
pub type RGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN0WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN0WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` reader - Enable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_R = crate::BitReader<RGN0RA_A>;
|
||||
#[doc = "Enable read access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN0RA_A {
|
||||
match self.bits {
|
||||
false => RGN0RA_A::DISABLED,
|
||||
true => RGN0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in region\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN0RA_AW {
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN0RA` writer - Enable read access watch in region\\[0\\]"]
|
||||
pub type RGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN0RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN0RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` reader - Enable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_R = crate::BitReader<RGN1WA_A>;
|
||||
#[doc = "Enable write access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1WA_A {
|
||||
match self.bits {
|
||||
false => RGN1WA_A::DISABLED,
|
||||
true => RGN1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1WA_AW {
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1WA` writer - Enable write access watch in region\\[1\\]"]
|
||||
pub type RGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN1WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN1WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` reader - Enable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_R = crate::BitReader<RGN1RA_A>;
|
||||
#[doc = "Enable read access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN1RA_A {
|
||||
match self.bits {
|
||||
false => RGN1RA_A::DISABLED,
|
||||
true => RGN1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in region\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN1RA_AW {
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN1RA` writer - Enable read access watch in region\\[1\\]"]
|
||||
pub type RGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN1RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN1RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` reader - Enable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_R = crate::BitReader<RGN2WA_A>;
|
||||
#[doc = "Enable write access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN2WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2WA_A {
|
||||
match self.bits {
|
||||
false => RGN2WA_A::DISABLED,
|
||||
true => RGN2WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN2WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN2WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2WA_AW {
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN2WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2WA` writer - Enable write access watch in region\\[2\\]"]
|
||||
pub type RGN2WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN2WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN2WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN2WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` reader - Enable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_R = crate::BitReader<RGN2RA_A>;
|
||||
#[doc = "Enable read access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN2RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN2RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN2RA_A {
|
||||
match self.bits {
|
||||
false => RGN2RA_A::DISABLED,
|
||||
true => RGN2RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN2RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN2RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in region\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN2RA_AW {
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN2RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN2RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN2RA` writer - Enable read access watch in region\\[2\\]"]
|
||||
pub type RGN2RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN2RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN2RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN2RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` reader - Enable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_R = crate::BitReader<RGN3WA_A>;
|
||||
#[doc = "Enable write access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3WA_A {
|
||||
#[doc = "0: Write access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN3WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3WA_A {
|
||||
match self.bits {
|
||||
false => RGN3WA_A::DISABLED,
|
||||
true => RGN3WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN3WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN3WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3WA_AW {
|
||||
#[doc = "1: Enable write access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN3WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3WA` writer - Enable write access watch in region\\[3\\]"]
|
||||
pub type RGN3WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN3WA_AW, O>;
|
||||
impl<'a, const O: u8> RGN3WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN3WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` reader - Enable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_R = crate::BitReader<RGN3RA_A>;
|
||||
#[doc = "Enable read access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3RA_A {
|
||||
#[doc = "0: Read access watch in this region is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this region is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RGN3RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RGN3RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RGN3RA_A {
|
||||
match self.bits {
|
||||
false => RGN3RA_A::DISABLED,
|
||||
true => RGN3RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RGN3RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RGN3RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in region\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RGN3RA_AW {
|
||||
#[doc = "1: Enable read access watch in this region"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RGN3RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RGN3RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RGN3RA` writer - Enable read access watch in region\\[3\\]"]
|
||||
pub type RGN3RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, RGN3RA_AW, O>;
|
||||
impl<'a, const O: u8> RGN3RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this region"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RGN3RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` reader - Enable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_R = crate::BitReader<PRGN0WA_A>;
|
||||
#[doc = "Enable write access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0WA_A {
|
||||
#[doc = "0: Write access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN0WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0WA_A {
|
||||
match self.bits {
|
||||
false => PRGN0WA_A::DISABLED,
|
||||
true => PRGN0WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN0WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN0WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0WA_AW {
|
||||
#[doc = "1: Enable write access watch in this PREGION"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PRGN0WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0WA` writer - Enable write access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, PRGN0WA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN0WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PRGN0WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` reader - Enable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_R = crate::BitReader<PRGN0RA_A>;
|
||||
#[doc = "Enable read access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0RA_A {
|
||||
#[doc = "0: Read access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN0RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN0RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN0RA_A {
|
||||
match self.bits {
|
||||
false => PRGN0RA_A::DISABLED,
|
||||
true => PRGN0RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN0RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN0RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in PREGION\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN0RA_AW {
|
||||
#[doc = "1: Enable read access watch in this PREGION"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PRGN0RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN0RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN0RA` writer - Enable read access watch in PREGION\\[0\\]"]
|
||||
pub type PRGN0RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, PRGN0RA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN0RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PRGN0RA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` reader - Enable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_R = crate::BitReader<PRGN1WA_A>;
|
||||
#[doc = "Enable write access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1WA_A {
|
||||
#[doc = "0: Write access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Write access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN1WA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1WA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1WA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1WA_A {
|
||||
match self.bits {
|
||||
false => PRGN1WA_A::DISABLED,
|
||||
true => PRGN1WA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN1WA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN1WA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable write access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1WA_AW {
|
||||
#[doc = "1: Enable write access watch in this PREGION"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PRGN1WA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1WA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1WA` writer - Enable write access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1WA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, PRGN1WA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN1WA_W<'a, O> {
|
||||
#[doc = "Enable write access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PRGN1WA_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` reader - Enable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_R = crate::BitReader<PRGN1RA_A>;
|
||||
#[doc = "Enable read access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1RA_A {
|
||||
#[doc = "0: Read access watch in this PREGION is disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read access watch in this PREGION is enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<PRGN1RA_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1RA_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl PRGN1RA_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> PRGN1RA_A {
|
||||
match self.bits {
|
||||
false => PRGN1RA_A::DISABLED,
|
||||
true => PRGN1RA_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == PRGN1RA_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == PRGN1RA_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Enable read access watch in PREGION\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum PRGN1RA_AW {
|
||||
#[doc = "1: Enable read access watch in this PREGION"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<PRGN1RA_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: PRGN1RA_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRGN1RA` writer - Enable read access watch in PREGION\\[1\\]"]
|
||||
pub type PRGN1RA_W<'a, const O: u8> = crate::BitWriter<'a, u32, REGIONENSET_SPEC, PRGN1RA_AW, O>;
|
||||
impl<'a, const O: u8> PRGN1RA_W<'a, O> {
|
||||
#[doc = "Enable read access watch in this PREGION"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(PRGN1RA_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&self) -> RGN0WA_R {
|
||||
RGN0WA_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&self) -> RGN0RA_R {
|
||||
RGN0RA_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&self) -> RGN1WA_R {
|
||||
RGN1WA_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&self) -> RGN1RA_R {
|
||||
RGN1RA_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&self) -> RGN2WA_R {
|
||||
RGN2WA_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&self) -> RGN2RA_R {
|
||||
RGN2RA_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&self) -> RGN3WA_R {
|
||||
RGN3WA_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&self) -> RGN3RA_R {
|
||||
RGN3RA_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&self) -> PRGN0WA_R {
|
||||
PRGN0WA_R::new(((self.bits >> 24) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&self) -> PRGN0RA_R {
|
||||
PRGN0RA_R::new(((self.bits >> 25) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&self) -> PRGN1WA_R {
|
||||
PRGN1WA_R::new(((self.bits >> 26) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&self) -> PRGN1RA_R {
|
||||
PRGN1RA_R::new(((self.bits >> 27) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable write access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0wa(&mut self) -> RGN0WA_W<0> {
|
||||
RGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable read access watch in region\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn0ra(&mut self) -> RGN0RA_W<1> {
|
||||
RGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable write access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1wa(&mut self) -> RGN1WA_W<2> {
|
||||
RGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable read access watch in region\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn1ra(&mut self) -> RGN1RA_W<3> {
|
||||
RGN1RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable write access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2wa(&mut self) -> RGN2WA_W<4> {
|
||||
RGN2WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable read access watch in region\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn2ra(&mut self) -> RGN2RA_W<5> {
|
||||
RGN2RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable write access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3wa(&mut self) -> RGN3WA_W<6> {
|
||||
RGN3WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable read access watch in region\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn rgn3ra(&mut self) -> RGN3RA_W<7> {
|
||||
RGN3RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 24 - Enable write access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0wa(&mut self) -> PRGN0WA_W<24> {
|
||||
PRGN0WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 25 - Enable read access watch in PREGION\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn0ra(&mut self) -> PRGN0RA_W<25> {
|
||||
PRGN0RA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 26 - Enable write access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1wa(&mut self) -> PRGN1WA_W<26> {
|
||||
PRGN1WA_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 27 - Enable read access watch in PREGION\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn prgn1ra(&mut self) -> PRGN1RA_W<27> {
|
||||
PRGN1RA_W::new(self)
|
||||
}
|
||||
#[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 = "Enable regions watch\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 [regionenset](index.html) module"]
|
||||
pub struct REGIONENSET_SPEC;
|
||||
impl crate::RegisterSpec for REGIONENSET_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [regionenset::R](R) reader structure"]
|
||||
impl crate::Readable for REGIONENSET_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [regionenset::W](W) writer structure"]
|
||||
impl crate::Writable for REGIONENSET_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets REGIONENSET to value 0"]
|
||||
impl crate::Resettable for REGIONENSET_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user