swaits/donglora
Archived
1
0 Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2026-08-31. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
3102fc747ad2d00b98f767d539d2604d90944976
donglora/vendor/nrf5340-app-pac/src/spu_s/dppi/perm.rs
T
swaitsandClaude Opus 4.6 3102fc747a 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>
2026-03-29 20:42:54 -06:00

1987 lines
64 KiB
Rust
Raw Blame History

#[doc = "Register `PERM` reader"]
pub struct R(crate::R<PERM_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<PERM_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<PERM_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<PERM_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `PERM` writer"]
pub struct W(crate::W<PERM_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<PERM_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<PERM_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<PERM_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `CHANNEL0` reader - Select secure attribute"]
pub type CHANNEL0_R = crate::BitReader<CHANNEL0_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL0_A {
#[doc = "1: Channel 0 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 0 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL0_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL0_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL0_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL0_A {
match self.bits {
true => CHANNEL0_A::SECURE,
false => CHANNEL0_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL0_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL0_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL0` writer - Select secure attribute"]
pub type CHANNEL0_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL0_A, O>;
impl<'a, const O: u8> CHANNEL0_W<'a, O> {
#[doc = "Channel 0 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL0_A::SECURE)
}
#[doc = "Channel 0 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL0_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL1` reader - Select secure attribute"]
pub type CHANNEL1_R = crate::BitReader<CHANNEL1_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL1_A {
#[doc = "1: Channel 1 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 1 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL1_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL1_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL1_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL1_A {
match self.bits {
true => CHANNEL1_A::SECURE,
false => CHANNEL1_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL1_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL1_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL1` writer - Select secure attribute"]
pub type CHANNEL1_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL1_A, O>;
impl<'a, const O: u8> CHANNEL1_W<'a, O> {
#[doc = "Channel 1 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL1_A::SECURE)
}
#[doc = "Channel 1 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL1_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL2` reader - Select secure attribute"]
pub type CHANNEL2_R = crate::BitReader<CHANNEL2_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL2_A {
#[doc = "1: Channel 2 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 2 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL2_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL2_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL2_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL2_A {
match self.bits {
true => CHANNEL2_A::SECURE,
false => CHANNEL2_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL2_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL2_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL2` writer - Select secure attribute"]
pub type CHANNEL2_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL2_A, O>;
impl<'a, const O: u8> CHANNEL2_W<'a, O> {
#[doc = "Channel 2 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL2_A::SECURE)
}
#[doc = "Channel 2 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL2_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL3` reader - Select secure attribute"]
pub type CHANNEL3_R = crate::BitReader<CHANNEL3_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL3_A {
#[doc = "1: Channel 3 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 3 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL3_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL3_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL3_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL3_A {
match self.bits {
true => CHANNEL3_A::SECURE,
false => CHANNEL3_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL3_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL3_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL3` writer - Select secure attribute"]
pub type CHANNEL3_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL3_A, O>;
impl<'a, const O: u8> CHANNEL3_W<'a, O> {
#[doc = "Channel 3 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL3_A::SECURE)
}
#[doc = "Channel 3 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL3_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL4` reader - Select secure attribute"]
pub type CHANNEL4_R = crate::BitReader<CHANNEL4_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL4_A {
#[doc = "1: Channel 4 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 4 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL4_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL4_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL4_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL4_A {
match self.bits {
true => CHANNEL4_A::SECURE,
false => CHANNEL4_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL4_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL4_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL4` writer - Select secure attribute"]
pub type CHANNEL4_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL4_A, O>;
impl<'a, const O: u8> CHANNEL4_W<'a, O> {
#[doc = "Channel 4 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL4_A::SECURE)
}
#[doc = "Channel 4 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL4_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL5` reader - Select secure attribute"]
pub type CHANNEL5_R = crate::BitReader<CHANNEL5_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL5_A {
#[doc = "1: Channel 5 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 5 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL5_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL5_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL5_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL5_A {
match self.bits {
true => CHANNEL5_A::SECURE,
false => CHANNEL5_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL5_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL5_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL5` writer - Select secure attribute"]
pub type CHANNEL5_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL5_A, O>;
impl<'a, const O: u8> CHANNEL5_W<'a, O> {
#[doc = "Channel 5 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL5_A::SECURE)
}
#[doc = "Channel 5 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL5_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL6` reader - Select secure attribute"]
pub type CHANNEL6_R = crate::BitReader<CHANNEL6_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL6_A {
#[doc = "1: Channel 6 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 6 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL6_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL6_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL6_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL6_A {
match self.bits {
true => CHANNEL6_A::SECURE,
false => CHANNEL6_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL6_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL6_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL6` writer - Select secure attribute"]
pub type CHANNEL6_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL6_A, O>;
impl<'a, const O: u8> CHANNEL6_W<'a, O> {
#[doc = "Channel 6 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL6_A::SECURE)
}
#[doc = "Channel 6 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL6_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL7` reader - Select secure attribute"]
pub type CHANNEL7_R = crate::BitReader<CHANNEL7_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL7_A {
#[doc = "1: Channel 7 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 7 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL7_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL7_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL7_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL7_A {
match self.bits {
true => CHANNEL7_A::SECURE,
false => CHANNEL7_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL7_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL7_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL7` writer - Select secure attribute"]
pub type CHANNEL7_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL7_A, O>;
impl<'a, const O: u8> CHANNEL7_W<'a, O> {
#[doc = "Channel 7 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL7_A::SECURE)
}
#[doc = "Channel 7 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL7_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL8` reader - Select secure attribute"]
pub type CHANNEL8_R = crate::BitReader<CHANNEL8_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL8_A {
#[doc = "1: Channel 8 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 8 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL8_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL8_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL8_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL8_A {
match self.bits {
true => CHANNEL8_A::SECURE,
false => CHANNEL8_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL8_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL8_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL8` writer - Select secure attribute"]
pub type CHANNEL8_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL8_A, O>;
impl<'a, const O: u8> CHANNEL8_W<'a, O> {
#[doc = "Channel 8 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL8_A::SECURE)
}
#[doc = "Channel 8 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL8_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL9` reader - Select secure attribute"]
pub type CHANNEL9_R = crate::BitReader<CHANNEL9_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL9_A {
#[doc = "1: Channel 9 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 9 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL9_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL9_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL9_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL9_A {
match self.bits {
true => CHANNEL9_A::SECURE,
false => CHANNEL9_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL9_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL9_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL9` writer - Select secure attribute"]
pub type CHANNEL9_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL9_A, O>;
impl<'a, const O: u8> CHANNEL9_W<'a, O> {
#[doc = "Channel 9 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL9_A::SECURE)
}
#[doc = "Channel 9 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL9_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL10` reader - Select secure attribute"]
pub type CHANNEL10_R = crate::BitReader<CHANNEL10_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL10_A {
#[doc = "1: Channel 10 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 10 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL10_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL10_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL10_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL10_A {
match self.bits {
true => CHANNEL10_A::SECURE,
false => CHANNEL10_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL10_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL10_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL10` writer - Select secure attribute"]
pub type CHANNEL10_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL10_A, O>;
impl<'a, const O: u8> CHANNEL10_W<'a, O> {
#[doc = "Channel 10 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL10_A::SECURE)
}
#[doc = "Channel 10 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL10_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL11` reader - Select secure attribute"]
pub type CHANNEL11_R = crate::BitReader<CHANNEL11_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL11_A {
#[doc = "1: Channel 11 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 11 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL11_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL11_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL11_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL11_A {
match self.bits {
true => CHANNEL11_A::SECURE,
false => CHANNEL11_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL11_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL11_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL11` writer - Select secure attribute"]
pub type CHANNEL11_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL11_A, O>;
impl<'a, const O: u8> CHANNEL11_W<'a, O> {
#[doc = "Channel 11 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL11_A::SECURE)
}
#[doc = "Channel 11 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL11_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL12` reader - Select secure attribute"]
pub type CHANNEL12_R = crate::BitReader<CHANNEL12_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL12_A {
#[doc = "1: Channel 12 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 12 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL12_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL12_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL12_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL12_A {
match self.bits {
true => CHANNEL12_A::SECURE,
false => CHANNEL12_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL12_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL12_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL12` writer - Select secure attribute"]
pub type CHANNEL12_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL12_A, O>;
impl<'a, const O: u8> CHANNEL12_W<'a, O> {
#[doc = "Channel 12 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL12_A::SECURE)
}
#[doc = "Channel 12 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL12_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL13` reader - Select secure attribute"]
pub type CHANNEL13_R = crate::BitReader<CHANNEL13_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL13_A {
#[doc = "1: Channel 13 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 13 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL13_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL13_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL13_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL13_A {
match self.bits {
true => CHANNEL13_A::SECURE,
false => CHANNEL13_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL13_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL13_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL13` writer - Select secure attribute"]
pub type CHANNEL13_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL13_A, O>;
impl<'a, const O: u8> CHANNEL13_W<'a, O> {
#[doc = "Channel 13 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL13_A::SECURE)
}
#[doc = "Channel 13 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL13_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL14` reader - Select secure attribute"]
pub type CHANNEL14_R = crate::BitReader<CHANNEL14_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL14_A {
#[doc = "1: Channel 14 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 14 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL14_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL14_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL14_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL14_A {
match self.bits {
true => CHANNEL14_A::SECURE,
false => CHANNEL14_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL14_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL14_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL14` writer - Select secure attribute"]
pub type CHANNEL14_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL14_A, O>;
impl<'a, const O: u8> CHANNEL14_W<'a, O> {
#[doc = "Channel 14 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL14_A::SECURE)
}
#[doc = "Channel 14 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL14_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL15` reader - Select secure attribute"]
pub type CHANNEL15_R = crate::BitReader<CHANNEL15_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL15_A {
#[doc = "1: Channel 15 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 15 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL15_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL15_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL15_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL15_A {
match self.bits {
true => CHANNEL15_A::SECURE,
false => CHANNEL15_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL15_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL15_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL15` writer - Select secure attribute"]
pub type CHANNEL15_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL15_A, O>;
impl<'a, const O: u8> CHANNEL15_W<'a, O> {
#[doc = "Channel 15 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL15_A::SECURE)
}
#[doc = "Channel 15 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL15_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL16` reader - Select secure attribute"]
pub type CHANNEL16_R = crate::BitReader<CHANNEL16_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL16_A {
#[doc = "1: Channel 16 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 16 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL16_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL16_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL16_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL16_A {
match self.bits {
true => CHANNEL16_A::SECURE,
false => CHANNEL16_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL16_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL16_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL16` writer - Select secure attribute"]
pub type CHANNEL16_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL16_A, O>;
impl<'a, const O: u8> CHANNEL16_W<'a, O> {
#[doc = "Channel 16 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL16_A::SECURE)
}
#[doc = "Channel 16 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL16_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL17` reader - Select secure attribute"]
pub type CHANNEL17_R = crate::BitReader<CHANNEL17_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL17_A {
#[doc = "1: Channel 17 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 17 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL17_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL17_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL17_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL17_A {
match self.bits {
true => CHANNEL17_A::SECURE,
false => CHANNEL17_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL17_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL17_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL17` writer - Select secure attribute"]
pub type CHANNEL17_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL17_A, O>;
impl<'a, const O: u8> CHANNEL17_W<'a, O> {
#[doc = "Channel 17 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL17_A::SECURE)
}
#[doc = "Channel 17 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL17_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL18` reader - Select secure attribute"]
pub type CHANNEL18_R = crate::BitReader<CHANNEL18_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL18_A {
#[doc = "1: Channel 18 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 18 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL18_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL18_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL18_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL18_A {
match self.bits {
true => CHANNEL18_A::SECURE,
false => CHANNEL18_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL18_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL18_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL18` writer - Select secure attribute"]
pub type CHANNEL18_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL18_A, O>;
impl<'a, const O: u8> CHANNEL18_W<'a, O> {
#[doc = "Channel 18 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL18_A::SECURE)
}
#[doc = "Channel 18 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL18_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL19` reader - Select secure attribute"]
pub type CHANNEL19_R = crate::BitReader<CHANNEL19_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL19_A {
#[doc = "1: Channel 19 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 19 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL19_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL19_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL19_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL19_A {
match self.bits {
true => CHANNEL19_A::SECURE,
false => CHANNEL19_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL19_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL19_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL19` writer - Select secure attribute"]
pub type CHANNEL19_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL19_A, O>;
impl<'a, const O: u8> CHANNEL19_W<'a, O> {
#[doc = "Channel 19 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL19_A::SECURE)
}
#[doc = "Channel 19 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL19_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL20` reader - Select secure attribute"]
pub type CHANNEL20_R = crate::BitReader<CHANNEL20_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL20_A {
#[doc = "1: Channel 20 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 20 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL20_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL20_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL20_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL20_A {
match self.bits {
true => CHANNEL20_A::SECURE,
false => CHANNEL20_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL20_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL20_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL20` writer - Select secure attribute"]
pub type CHANNEL20_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL20_A, O>;
impl<'a, const O: u8> CHANNEL20_W<'a, O> {
#[doc = "Channel 20 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL20_A::SECURE)
}
#[doc = "Channel 20 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL20_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL21` reader - Select secure attribute"]
pub type CHANNEL21_R = crate::BitReader<CHANNEL21_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL21_A {
#[doc = "1: Channel 21 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 21 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL21_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL21_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL21_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL21_A {
match self.bits {
true => CHANNEL21_A::SECURE,
false => CHANNEL21_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL21_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL21_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL21` writer - Select secure attribute"]
pub type CHANNEL21_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL21_A, O>;
impl<'a, const O: u8> CHANNEL21_W<'a, O> {
#[doc = "Channel 21 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL21_A::SECURE)
}
#[doc = "Channel 21 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL21_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL22` reader - Select secure attribute"]
pub type CHANNEL22_R = crate::BitReader<CHANNEL22_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL22_A {
#[doc = "1: Channel 22 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 22 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL22_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL22_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL22_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL22_A {
match self.bits {
true => CHANNEL22_A::SECURE,
false => CHANNEL22_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL22_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL22_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL22` writer - Select secure attribute"]
pub type CHANNEL22_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL22_A, O>;
impl<'a, const O: u8> CHANNEL22_W<'a, O> {
#[doc = "Channel 22 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL22_A::SECURE)
}
#[doc = "Channel 22 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL22_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL23` reader - Select secure attribute"]
pub type CHANNEL23_R = crate::BitReader<CHANNEL23_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL23_A {
#[doc = "1: Channel 23 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 23 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL23_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL23_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL23_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL23_A {
match self.bits {
true => CHANNEL23_A::SECURE,
false => CHANNEL23_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL23_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL23_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL23` writer - Select secure attribute"]
pub type CHANNEL23_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL23_A, O>;
impl<'a, const O: u8> CHANNEL23_W<'a, O> {
#[doc = "Channel 23 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL23_A::SECURE)
}
#[doc = "Channel 23 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL23_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL24` reader - Select secure attribute"]
pub type CHANNEL24_R = crate::BitReader<CHANNEL24_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL24_A {
#[doc = "1: Channel 24 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 24 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL24_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL24_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL24_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL24_A {
match self.bits {
true => CHANNEL24_A::SECURE,
false => CHANNEL24_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL24_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL24_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL24` writer - Select secure attribute"]
pub type CHANNEL24_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL24_A, O>;
impl<'a, const O: u8> CHANNEL24_W<'a, O> {
#[doc = "Channel 24 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL24_A::SECURE)
}
#[doc = "Channel 24 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL24_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL25` reader - Select secure attribute"]
pub type CHANNEL25_R = crate::BitReader<CHANNEL25_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL25_A {
#[doc = "1: Channel 25 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 25 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL25_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL25_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL25_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL25_A {
match self.bits {
true => CHANNEL25_A::SECURE,
false => CHANNEL25_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL25_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL25_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL25` writer - Select secure attribute"]
pub type CHANNEL25_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL25_A, O>;
impl<'a, const O: u8> CHANNEL25_W<'a, O> {
#[doc = "Channel 25 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL25_A::SECURE)
}
#[doc = "Channel 25 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL25_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL26` reader - Select secure attribute"]
pub type CHANNEL26_R = crate::BitReader<CHANNEL26_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL26_A {
#[doc = "1: Channel 26 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 26 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL26_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL26_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL26_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL26_A {
match self.bits {
true => CHANNEL26_A::SECURE,
false => CHANNEL26_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL26_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL26_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL26` writer - Select secure attribute"]
pub type CHANNEL26_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL26_A, O>;
impl<'a, const O: u8> CHANNEL26_W<'a, O> {
#[doc = "Channel 26 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL26_A::SECURE)
}
#[doc = "Channel 26 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL26_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL27` reader - Select secure attribute"]
pub type CHANNEL27_R = crate::BitReader<CHANNEL27_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL27_A {
#[doc = "1: Channel 27 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 27 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL27_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL27_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL27_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL27_A {
match self.bits {
true => CHANNEL27_A::SECURE,
false => CHANNEL27_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL27_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL27_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL27` writer - Select secure attribute"]
pub type CHANNEL27_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL27_A, O>;
impl<'a, const O: u8> CHANNEL27_W<'a, O> {
#[doc = "Channel 27 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL27_A::SECURE)
}
#[doc = "Channel 27 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL27_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL28` reader - Select secure attribute"]
pub type CHANNEL28_R = crate::BitReader<CHANNEL28_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL28_A {
#[doc = "1: Channel 28 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 28 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL28_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL28_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL28_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL28_A {
match self.bits {
true => CHANNEL28_A::SECURE,
false => CHANNEL28_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL28_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL28_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL28` writer - Select secure attribute"]
pub type CHANNEL28_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL28_A, O>;
impl<'a, const O: u8> CHANNEL28_W<'a, O> {
#[doc = "Channel 28 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL28_A::SECURE)
}
#[doc = "Channel 28 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL28_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL29` reader - Select secure attribute"]
pub type CHANNEL29_R = crate::BitReader<CHANNEL29_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL29_A {
#[doc = "1: Channel 29 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 29 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL29_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL29_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL29_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL29_A {
match self.bits {
true => CHANNEL29_A::SECURE,
false => CHANNEL29_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL29_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL29_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL29` writer - Select secure attribute"]
pub type CHANNEL29_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL29_A, O>;
impl<'a, const O: u8> CHANNEL29_W<'a, O> {
#[doc = "Channel 29 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL29_A::SECURE)
}
#[doc = "Channel 29 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL29_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL30` reader - Select secure attribute"]
pub type CHANNEL30_R = crate::BitReader<CHANNEL30_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL30_A {
#[doc = "1: Channel 30 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 30 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL30_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL30_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL30_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL30_A {
match self.bits {
true => CHANNEL30_A::SECURE,
false => CHANNEL30_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL30_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL30_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL30` writer - Select secure attribute"]
pub type CHANNEL30_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL30_A, O>;
impl<'a, const O: u8> CHANNEL30_W<'a, O> {
#[doc = "Channel 30 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL30_A::SECURE)
}
#[doc = "Channel 30 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL30_A::NON_SECURE)
}
}
#[doc = "Field `CHANNEL31` reader - Select secure attribute"]
pub type CHANNEL31_R = crate::BitReader<CHANNEL31_A>;
#[doc = "Select secure attribute\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CHANNEL31_A {
#[doc = "1: Channel 31 has its secure attribute set"]
SECURE = 1,
#[doc = "0: Channel 31 has its non-secure attribute set"]
NON_SECURE = 0,
}
impl From<CHANNEL31_A> for bool {
#[inline(always)]
fn from(variant: CHANNEL31_A) -> Self {
variant as u8 != 0
}
}
impl CHANNEL31_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CHANNEL31_A {
match self.bits {
true => CHANNEL31_A::SECURE,
false => CHANNEL31_A::NON_SECURE,
}
}
#[doc = "Checks if the value of the field is `SECURE`"]
#[inline(always)]
pub fn is_secure(&self) -> bool {
*self == CHANNEL31_A::SECURE
}
#[doc = "Checks if the value of the field is `NON_SECURE`"]
#[inline(always)]
pub fn is_non_secure(&self) -> bool {
*self == CHANNEL31_A::NON_SECURE
}
}
#[doc = "Field `CHANNEL31` writer - Select secure attribute"]
pub type CHANNEL31_W<'a, const O: u8> = crate::BitWriter<'a, u32, PERM_SPEC, CHANNEL31_A, O>;
impl<'a, const O: u8> CHANNEL31_W<'a, O> {
#[doc = "Channel 31 has its secure attribute set"]
#[inline(always)]
pub fn secure(self) -> &'a mut W {
self.variant(CHANNEL31_A::SECURE)
}
#[doc = "Channel 31 has its non-secure attribute set"]
#[inline(always)]
pub fn non_secure(self) -> &'a mut W {
self.variant(CHANNEL31_A::NON_SECURE)
}
}
impl R {
#[doc = "Bit 0 - Select secure attribute"]
#[inline(always)]
pub fn channel0(&self) -> CHANNEL0_R {
CHANNEL0_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - Select secure attribute"]
#[inline(always)]
pub fn channel1(&self) -> CHANNEL1_R {
CHANNEL1_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - Select secure attribute"]
#[inline(always)]
pub fn channel2(&self) -> CHANNEL2_R {
CHANNEL2_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Select secure attribute"]
#[inline(always)]
pub fn channel3(&self) -> CHANNEL3_R {
CHANNEL3_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Select secure attribute"]
#[inline(always)]
pub fn channel4(&self) -> CHANNEL4_R {
CHANNEL4_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Select secure attribute"]
#[inline(always)]
pub fn channel5(&self) -> CHANNEL5_R {
CHANNEL5_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Select secure attribute"]
#[inline(always)]
pub fn channel6(&self) -> CHANNEL6_R {
CHANNEL6_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - Select secure attribute"]
#[inline(always)]
pub fn channel7(&self) -> CHANNEL7_R {
CHANNEL7_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - Select secure attribute"]
#[inline(always)]
pub fn channel8(&self) -> CHANNEL8_R {
CHANNEL8_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Select secure attribute"]
#[inline(always)]
pub fn channel9(&self) -> CHANNEL9_R {
CHANNEL9_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Select secure attribute"]
#[inline(always)]
pub fn channel10(&self) -> CHANNEL10_R {
CHANNEL10_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Select secure attribute"]
#[inline(always)]
pub fn channel11(&self) -> CHANNEL11_R {
CHANNEL11_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - Select secure attribute"]
#[inline(always)]
pub fn channel12(&self) -> CHANNEL12_R {
CHANNEL12_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - Select secure attribute"]
#[inline(always)]
pub fn channel13(&self) -> CHANNEL13_R {
CHANNEL13_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - Select secure attribute"]
#[inline(always)]
pub fn channel14(&self) -> CHANNEL14_R {
CHANNEL14_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - Select secure attribute"]
#[inline(always)]
pub fn channel15(&self) -> CHANNEL15_R {
CHANNEL15_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - Select secure attribute"]
#[inline(always)]
pub fn channel16(&self) -> CHANNEL16_R {
CHANNEL16_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - Select secure attribute"]
#[inline(always)]
pub fn channel17(&self) -> CHANNEL17_R {
CHANNEL17_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - Select secure attribute"]
#[inline(always)]
pub fn channel18(&self) -> CHANNEL18_R {
CHANNEL18_R::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - Select secure attribute"]
#[inline(always)]
pub fn channel19(&self) -> CHANNEL19_R {
CHANNEL19_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - Select secure attribute"]
#[inline(always)]
pub fn channel20(&self) -> CHANNEL20_R {
CHANNEL20_R::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bit 21 - Select secure attribute"]
#[inline(always)]
pub fn channel21(&self) -> CHANNEL21_R {
CHANNEL21_R::new(((self.bits >> 21) & 1) != 0)
}
#[doc = "Bit 22 - Select secure attribute"]
#[inline(always)]
pub fn channel22(&self) -> CHANNEL22_R {
CHANNEL22_R::new(((self.bits >> 22) & 1) != 0)
}
#[doc = "Bit 23 - Select secure attribute"]
#[inline(always)]
pub fn channel23(&self) -> CHANNEL23_R {
CHANNEL23_R::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - Select secure attribute"]
#[inline(always)]
pub fn channel24(&self) -> CHANNEL24_R {
CHANNEL24_R::new(((self.bits >> 24) & 1) != 0)
}
#[doc = "Bit 25 - Select secure attribute"]
#[inline(always)]
pub fn channel25(&self) -> CHANNEL25_R {
CHANNEL25_R::new(((self.bits >> 25) & 1) != 0)
}
#[doc = "Bit 26 - Select secure attribute"]
#[inline(always)]
pub fn channel26(&self) -> CHANNEL26_R {
CHANNEL26_R::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 27 - Select secure attribute"]
#[inline(always)]
pub fn channel27(&self) -> CHANNEL27_R {
CHANNEL27_R::new(((self.bits >> 27) & 1) != 0)
}
#[doc = "Bit 28 - Select secure attribute"]
#[inline(always)]
pub fn channel28(&self) -> CHANNEL28_R {
CHANNEL28_R::new(((self.bits >> 28) & 1) != 0)
}
#[doc = "Bit 29 - Select secure attribute"]
#[inline(always)]
pub fn channel29(&self) -> CHANNEL29_R {
CHANNEL29_R::new(((self.bits >> 29) & 1) != 0)
}
#[doc = "Bit 30 - Select secure attribute"]
#[inline(always)]
pub fn channel30(&self) -> CHANNEL30_R {
CHANNEL30_R::new(((self.bits >> 30) & 1) != 0)
}
#[doc = "Bit 31 - Select secure attribute"]
#[inline(always)]
pub fn channel31(&self) -> CHANNEL31_R {
CHANNEL31_R::new(((self.bits >> 31) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - Select secure attribute"]
#[inline(always)]
pub fn channel0(&mut self) -> CHANNEL0_W<0> {
CHANNEL0_W::new(self)
}
#[doc = "Bit 1 - Select secure attribute"]
#[inline(always)]
pub fn channel1(&mut self) -> CHANNEL1_W<1> {
CHANNEL1_W::new(self)
}
#[doc = "Bit 2 - Select secure attribute"]
#[inline(always)]
pub fn channel2(&mut self) -> CHANNEL2_W<2> {
CHANNEL2_W::new(self)
}
#[doc = "Bit 3 - Select secure attribute"]
#[inline(always)]
pub fn channel3(&mut self) -> CHANNEL3_W<3> {
CHANNEL3_W::new(self)
}
#[doc = "Bit 4 - Select secure attribute"]
#[inline(always)]
pub fn channel4(&mut self) -> CHANNEL4_W<4> {
CHANNEL4_W::new(self)
}
#[doc = "Bit 5 - Select secure attribute"]
#[inline(always)]
pub fn channel5(&mut self) -> CHANNEL5_W<5> {
CHANNEL5_W::new(self)
}
#[doc = "Bit 6 - Select secure attribute"]
#[inline(always)]
pub fn channel6(&mut self) -> CHANNEL6_W<6> {
CHANNEL6_W::new(self)
}
#[doc = "Bit 7 - Select secure attribute"]
#[inline(always)]
pub fn channel7(&mut self) -> CHANNEL7_W<7> {
CHANNEL7_W::new(self)
}
#[doc = "Bit 8 - Select secure attribute"]
#[inline(always)]
pub fn channel8(&mut self) -> CHANNEL8_W<8> {
CHANNEL8_W::new(self)
}
#[doc = "Bit 9 - Select secure attribute"]
#[inline(always)]
pub fn channel9(&mut self) -> CHANNEL9_W<9> {
CHANNEL9_W::new(self)
}
#[doc = "Bit 10 - Select secure attribute"]
#[inline(always)]
pub fn channel10(&mut self) -> CHANNEL10_W<10> {
CHANNEL10_W::new(self)
}
#[doc = "Bit 11 - Select secure attribute"]
#[inline(always)]
pub fn channel11(&mut self) -> CHANNEL11_W<11> {
CHANNEL11_W::new(self)
}
#[doc = "Bit 12 - Select secure attribute"]
#[inline(always)]
pub fn channel12(&mut self) -> CHANNEL12_W<12> {
CHANNEL12_W::new(self)
}
#[doc = "Bit 13 - Select secure attribute"]
#[inline(always)]
pub fn channel13(&mut self) -> CHANNEL13_W<13> {
CHANNEL13_W::new(self)
}
#[doc = "Bit 14 - Select secure attribute"]
#[inline(always)]
pub fn channel14(&mut self) -> CHANNEL14_W<14> {
CHANNEL14_W::new(self)
}
#[doc = "Bit 15 - Select secure attribute"]
#[inline(always)]
pub fn channel15(&mut self) -> CHANNEL15_W<15> {
CHANNEL15_W::new(self)
}
#[doc = "Bit 16 - Select secure attribute"]
#[inline(always)]
pub fn channel16(&mut self) -> CHANNEL16_W<16> {
CHANNEL16_W::new(self)
}
#[doc = "Bit 17 - Select secure attribute"]
#[inline(always)]
pub fn channel17(&mut self) -> CHANNEL17_W<17> {
CHANNEL17_W::new(self)
}
#[doc = "Bit 18 - Select secure attribute"]
#[inline(always)]
pub fn channel18(&mut self) -> CHANNEL18_W<18> {
CHANNEL18_W::new(self)
}
#[doc = "Bit 19 - Select secure attribute"]
#[inline(always)]
pub fn channel19(&mut self) -> CHANNEL19_W<19> {
CHANNEL19_W::new(self)
}
#[doc = "Bit 20 - Select secure attribute"]
#[inline(always)]
pub fn channel20(&mut self) -> CHANNEL20_W<20> {
CHANNEL20_W::new(self)
}
#[doc = "Bit 21 - Select secure attribute"]
#[inline(always)]
pub fn channel21(&mut self) -> CHANNEL21_W<21> {
CHANNEL21_W::new(self)
}
#[doc = "Bit 22 - Select secure attribute"]
#[inline(always)]
pub fn channel22(&mut self) -> CHANNEL22_W<22> {
CHANNEL22_W::new(self)
}
#[doc = "Bit 23 - Select secure attribute"]
#[inline(always)]
pub fn channel23(&mut self) -> CHANNEL23_W<23> {
CHANNEL23_W::new(self)
}
#[doc = "Bit 24 - Select secure attribute"]
#[inline(always)]
pub fn channel24(&mut self) -> CHANNEL24_W<24> {
CHANNEL24_W::new(self)
}
#[doc = "Bit 25 - Select secure attribute"]
#[inline(always)]
pub fn channel25(&mut self) -> CHANNEL25_W<25> {
CHANNEL25_W::new(self)
}
#[doc = "Bit 26 - Select secure attribute"]
#[inline(always)]
pub fn channel26(&mut self) -> CHANNEL26_W<26> {
CHANNEL26_W::new(self)
}
#[doc = "Bit 27 - Select secure attribute"]
#[inline(always)]
pub fn channel27(&mut self) -> CHANNEL27_W<27> {
CHANNEL27_W::new(self)
}
#[doc = "Bit 28 - Select secure attribute"]
#[inline(always)]
pub fn channel28(&mut self) -> CHANNEL28_W<28> {
CHANNEL28_W::new(self)
}
#[doc = "Bit 29 - Select secure attribute"]
#[inline(always)]
pub fn channel29(&mut self) -> CHANNEL29_W<29> {
CHANNEL29_W::new(self)
}
#[doc = "Bit 30 - Select secure attribute"]
#[inline(always)]
pub fn channel30(&mut self) -> CHANNEL30_W<30> {
CHANNEL30_W::new(self)
}
#[doc = "Bit 31 - Select secure attribute"]
#[inline(always)]
pub fn channel31(&mut self) -> CHANNEL31_W<31> {
CHANNEL31_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: Select between secure and non-secure attribute for the DPPI channels\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 [perm](index.html) module"]
pub struct PERM_SPEC;
impl crate::RegisterSpec for PERM_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [perm::R](R) reader structure"]
impl crate::Readable for PERM_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [perm::W](W) writer structure"]
impl crate::Writable for PERM_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets PERM to value 0xffff_ffff"]
impl crate::Resettable for PERM_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0xffff_ffff
}
}
Reference in new issue View Git Blame Copy Permalink