1#[doc = "Register `SEC_GPIO_MASK0` reader"]
2pub struct R(crate::R<SEC_GPIO_MASK0_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<SEC_GPIO_MASK0_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<SEC_GPIO_MASK0_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<SEC_GPIO_MASK0_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `SEC_GPIO_MASK0` writer"]
17pub struct W(crate::W<SEC_GPIO_MASK0_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<SEC_GPIO_MASK0_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<SEC_GPIO_MASK0_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<SEC_GPIO_MASK0_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Secure mask for pin P0_0\n\nValue on reset: 1"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum PIO0_PIN0_SEC_MASK_A {
40 #[doc = "0: Pin state is blocked to non-secure world."]
41 BLOCKED = 0,
42 #[doc = "1: Pin state is readable by non-secure world."]
43 READABLE = 1,
44}
45impl From<PIO0_PIN0_SEC_MASK_A> for bool {
46 #[inline(always)]
47 fn from(variant: PIO0_PIN0_SEC_MASK_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `PIO0_PIN0_SEC_MASK` reader - Secure mask for pin P0_0"]
52pub struct PIO0_PIN0_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN0_SEC_MASK_A>);
53impl PIO0_PIN0_SEC_MASK_R {
54 #[inline(always)]
55 pub(crate) fn new(bits: bool) -> Self {
56 PIO0_PIN0_SEC_MASK_R(crate::FieldReader::new(bits))
57 }
58 #[doc = r"Get enumerated values variant"]
59 #[inline(always)]
60 pub fn variant(&self) -> PIO0_PIN0_SEC_MASK_A {
61 match self.bits {
62 false => PIO0_PIN0_SEC_MASK_A::BLOCKED,
63 true => PIO0_PIN0_SEC_MASK_A::READABLE,
64 }
65 }
66 #[doc = "Checks if the value of the field is `BLOCKED`"]
67 #[inline(always)]
68 pub fn is_blocked(&self) -> bool {
69 **self == PIO0_PIN0_SEC_MASK_A::BLOCKED
70 }
71 #[doc = "Checks if the value of the field is `READABLE`"]
72 #[inline(always)]
73 pub fn is_readable(&self) -> bool {
74 **self == PIO0_PIN0_SEC_MASK_A::READABLE
75 }
76}
77impl core::ops::Deref for PIO0_PIN0_SEC_MASK_R {
78 type Target = crate::FieldReader<bool, PIO0_PIN0_SEC_MASK_A>;
79 #[inline(always)]
80 fn deref(&self) -> &Self::Target {
81 &self.0
82 }
83}
84#[doc = "Field `PIO0_PIN0_SEC_MASK` writer - Secure mask for pin P0_0"]
85pub struct PIO0_PIN0_SEC_MASK_W<'a> {
86 w: &'a mut W,
87}
88impl<'a> PIO0_PIN0_SEC_MASK_W<'a> {
89 #[doc = r"Writes `variant` to the field"]
90 #[inline(always)]
91 pub fn variant(self, variant: PIO0_PIN0_SEC_MASK_A) -> &'a mut W {
92 self.bit(variant.into())
93 }
94 #[doc = "Pin state is blocked to non-secure world."]
95 #[inline(always)]
96 pub fn blocked(self) -> &'a mut W {
97 self.variant(PIO0_PIN0_SEC_MASK_A::BLOCKED)
98 }
99 #[doc = "Pin state is readable by non-secure world."]
100 #[inline(always)]
101 pub fn readable(self) -> &'a mut W {
102 self.variant(PIO0_PIN0_SEC_MASK_A::READABLE)
103 }
104 #[doc = r"Sets the field bit"]
105 #[inline(always)]
106 pub fn set_bit(self) -> &'a mut W {
107 self.bit(true)
108 }
109 #[doc = r"Clears the field bit"]
110 #[inline(always)]
111 pub fn clear_bit(self) -> &'a mut W {
112 self.bit(false)
113 }
114 #[doc = r"Writes raw bits to the field"]
115 #[inline(always)]
116 pub fn bit(self, value: bool) -> &'a mut W {
117 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
118 self.w
119 }
120}
121#[doc = "Secure mask for pin P0_1\n\nValue on reset: 1"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum PIO0_PIN1_SEC_MASK_A {
124 #[doc = "0: Pin state is blocked to non-secure world."]
125 BLOCKED = 0,
126 #[doc = "1: Pin state is readable by non-secure world."]
127 READABLE = 1,
128}
129impl From<PIO0_PIN1_SEC_MASK_A> for bool {
130 #[inline(always)]
131 fn from(variant: PIO0_PIN1_SEC_MASK_A) -> Self {
132 variant as u8 != 0
133 }
134}
135#[doc = "Field `PIO0_PIN1_SEC_MASK` reader - Secure mask for pin P0_1"]
136pub struct PIO0_PIN1_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN1_SEC_MASK_A>);
137impl PIO0_PIN1_SEC_MASK_R {
138 #[inline(always)]
139 pub(crate) fn new(bits: bool) -> Self {
140 PIO0_PIN1_SEC_MASK_R(crate::FieldReader::new(bits))
141 }
142 #[doc = r"Get enumerated values variant"]
143 #[inline(always)]
144 pub fn variant(&self) -> PIO0_PIN1_SEC_MASK_A {
145 match self.bits {
146 false => PIO0_PIN1_SEC_MASK_A::BLOCKED,
147 true => PIO0_PIN1_SEC_MASK_A::READABLE,
148 }
149 }
150 #[doc = "Checks if the value of the field is `BLOCKED`"]
151 #[inline(always)]
152 pub fn is_blocked(&self) -> bool {
153 **self == PIO0_PIN1_SEC_MASK_A::BLOCKED
154 }
155 #[doc = "Checks if the value of the field is `READABLE`"]
156 #[inline(always)]
157 pub fn is_readable(&self) -> bool {
158 **self == PIO0_PIN1_SEC_MASK_A::READABLE
159 }
160}
161impl core::ops::Deref for PIO0_PIN1_SEC_MASK_R {
162 type Target = crate::FieldReader<bool, PIO0_PIN1_SEC_MASK_A>;
163 #[inline(always)]
164 fn deref(&self) -> &Self::Target {
165 &self.0
166 }
167}
168#[doc = "Field `PIO0_PIN1_SEC_MASK` writer - Secure mask for pin P0_1"]
169pub struct PIO0_PIN1_SEC_MASK_W<'a> {
170 w: &'a mut W,
171}
172impl<'a> PIO0_PIN1_SEC_MASK_W<'a> {
173 #[doc = r"Writes `variant` to the field"]
174 #[inline(always)]
175 pub fn variant(self, variant: PIO0_PIN1_SEC_MASK_A) -> &'a mut W {
176 self.bit(variant.into())
177 }
178 #[doc = "Pin state is blocked to non-secure world."]
179 #[inline(always)]
180 pub fn blocked(self) -> &'a mut W {
181 self.variant(PIO0_PIN1_SEC_MASK_A::BLOCKED)
182 }
183 #[doc = "Pin state is readable by non-secure world."]
184 #[inline(always)]
185 pub fn readable(self) -> &'a mut W {
186 self.variant(PIO0_PIN1_SEC_MASK_A::READABLE)
187 }
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
202 self.w
203 }
204}
205#[doc = "Secure mask for pin P0_2\n\nValue on reset: 1"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum PIO0_PIN2_SEC_MASK_A {
208 #[doc = "0: Pin state is blocked to non-secure world."]
209 BLOCKED = 0,
210 #[doc = "1: Pin state is readable by non-secure world."]
211 READABLE = 1,
212}
213impl From<PIO0_PIN2_SEC_MASK_A> for bool {
214 #[inline(always)]
215 fn from(variant: PIO0_PIN2_SEC_MASK_A) -> Self {
216 variant as u8 != 0
217 }
218}
219#[doc = "Field `PIO0_PIN2_SEC_MASK` reader - Secure mask for pin P0_2"]
220pub struct PIO0_PIN2_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN2_SEC_MASK_A>);
221impl PIO0_PIN2_SEC_MASK_R {
222 #[inline(always)]
223 pub(crate) fn new(bits: bool) -> Self {
224 PIO0_PIN2_SEC_MASK_R(crate::FieldReader::new(bits))
225 }
226 #[doc = r"Get enumerated values variant"]
227 #[inline(always)]
228 pub fn variant(&self) -> PIO0_PIN2_SEC_MASK_A {
229 match self.bits {
230 false => PIO0_PIN2_SEC_MASK_A::BLOCKED,
231 true => PIO0_PIN2_SEC_MASK_A::READABLE,
232 }
233 }
234 #[doc = "Checks if the value of the field is `BLOCKED`"]
235 #[inline(always)]
236 pub fn is_blocked(&self) -> bool {
237 **self == PIO0_PIN2_SEC_MASK_A::BLOCKED
238 }
239 #[doc = "Checks if the value of the field is `READABLE`"]
240 #[inline(always)]
241 pub fn is_readable(&self) -> bool {
242 **self == PIO0_PIN2_SEC_MASK_A::READABLE
243 }
244}
245impl core::ops::Deref for PIO0_PIN2_SEC_MASK_R {
246 type Target = crate::FieldReader<bool, PIO0_PIN2_SEC_MASK_A>;
247 #[inline(always)]
248 fn deref(&self) -> &Self::Target {
249 &self.0
250 }
251}
252#[doc = "Field `PIO0_PIN2_SEC_MASK` writer - Secure mask for pin P0_2"]
253pub struct PIO0_PIN2_SEC_MASK_W<'a> {
254 w: &'a mut W,
255}
256impl<'a> PIO0_PIN2_SEC_MASK_W<'a> {
257 #[doc = r"Writes `variant` to the field"]
258 #[inline(always)]
259 pub fn variant(self, variant: PIO0_PIN2_SEC_MASK_A) -> &'a mut W {
260 self.bit(variant.into())
261 }
262 #[doc = "Pin state is blocked to non-secure world."]
263 #[inline(always)]
264 pub fn blocked(self) -> &'a mut W {
265 self.variant(PIO0_PIN2_SEC_MASK_A::BLOCKED)
266 }
267 #[doc = "Pin state is readable by non-secure world."]
268 #[inline(always)]
269 pub fn readable(self) -> &'a mut W {
270 self.variant(PIO0_PIN2_SEC_MASK_A::READABLE)
271 }
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
286 self.w
287 }
288}
289#[doc = "Secure mask for pin P0_3\n\nValue on reset: 1"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum PIO0_PIN3_SEC_MASK_A {
292 #[doc = "0: Pin state is blocked to non-secure world."]
293 BLOCKED = 0,
294 #[doc = "1: Pin state is readable by non-secure world."]
295 READABLE = 1,
296}
297impl From<PIO0_PIN3_SEC_MASK_A> for bool {
298 #[inline(always)]
299 fn from(variant: PIO0_PIN3_SEC_MASK_A) -> Self {
300 variant as u8 != 0
301 }
302}
303#[doc = "Field `PIO0_PIN3_SEC_MASK` reader - Secure mask for pin P0_3"]
304pub struct PIO0_PIN3_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN3_SEC_MASK_A>);
305impl PIO0_PIN3_SEC_MASK_R {
306 #[inline(always)]
307 pub(crate) fn new(bits: bool) -> Self {
308 PIO0_PIN3_SEC_MASK_R(crate::FieldReader::new(bits))
309 }
310 #[doc = r"Get enumerated values variant"]
311 #[inline(always)]
312 pub fn variant(&self) -> PIO0_PIN3_SEC_MASK_A {
313 match self.bits {
314 false => PIO0_PIN3_SEC_MASK_A::BLOCKED,
315 true => PIO0_PIN3_SEC_MASK_A::READABLE,
316 }
317 }
318 #[doc = "Checks if the value of the field is `BLOCKED`"]
319 #[inline(always)]
320 pub fn is_blocked(&self) -> bool {
321 **self == PIO0_PIN3_SEC_MASK_A::BLOCKED
322 }
323 #[doc = "Checks if the value of the field is `READABLE`"]
324 #[inline(always)]
325 pub fn is_readable(&self) -> bool {
326 **self == PIO0_PIN3_SEC_MASK_A::READABLE
327 }
328}
329impl core::ops::Deref for PIO0_PIN3_SEC_MASK_R {
330 type Target = crate::FieldReader<bool, PIO0_PIN3_SEC_MASK_A>;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 &self.0
334 }
335}
336#[doc = "Field `PIO0_PIN3_SEC_MASK` writer - Secure mask for pin P0_3"]
337pub struct PIO0_PIN3_SEC_MASK_W<'a> {
338 w: &'a mut W,
339}
340impl<'a> PIO0_PIN3_SEC_MASK_W<'a> {
341 #[doc = r"Writes `variant` to the field"]
342 #[inline(always)]
343 pub fn variant(self, variant: PIO0_PIN3_SEC_MASK_A) -> &'a mut W {
344 self.bit(variant.into())
345 }
346 #[doc = "Pin state is blocked to non-secure world."]
347 #[inline(always)]
348 pub fn blocked(self) -> &'a mut W {
349 self.variant(PIO0_PIN3_SEC_MASK_A::BLOCKED)
350 }
351 #[doc = "Pin state is readable by non-secure world."]
352 #[inline(always)]
353 pub fn readable(self) -> &'a mut W {
354 self.variant(PIO0_PIN3_SEC_MASK_A::READABLE)
355 }
356 #[doc = r"Sets the field bit"]
357 #[inline(always)]
358 pub fn set_bit(self) -> &'a mut W {
359 self.bit(true)
360 }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W {
364 self.bit(false)
365 }
366 #[doc = r"Writes raw bits to the field"]
367 #[inline(always)]
368 pub fn bit(self, value: bool) -> &'a mut W {
369 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
370 self.w
371 }
372}
373#[doc = "Secure mask for pin P0_4\n\nValue on reset: 1"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum PIO0_PIN4_SEC_MASK_A {
376 #[doc = "0: Pin state is blocked to non-secure world."]
377 BLOCKED = 0,
378 #[doc = "1: Pin state is readable by non-secure world."]
379 READABLE = 1,
380}
381impl From<PIO0_PIN4_SEC_MASK_A> for bool {
382 #[inline(always)]
383 fn from(variant: PIO0_PIN4_SEC_MASK_A) -> Self {
384 variant as u8 != 0
385 }
386}
387#[doc = "Field `PIO0_PIN4_SEC_MASK` reader - Secure mask for pin P0_4"]
388pub struct PIO0_PIN4_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN4_SEC_MASK_A>);
389impl PIO0_PIN4_SEC_MASK_R {
390 #[inline(always)]
391 pub(crate) fn new(bits: bool) -> Self {
392 PIO0_PIN4_SEC_MASK_R(crate::FieldReader::new(bits))
393 }
394 #[doc = r"Get enumerated values variant"]
395 #[inline(always)]
396 pub fn variant(&self) -> PIO0_PIN4_SEC_MASK_A {
397 match self.bits {
398 false => PIO0_PIN4_SEC_MASK_A::BLOCKED,
399 true => PIO0_PIN4_SEC_MASK_A::READABLE,
400 }
401 }
402 #[doc = "Checks if the value of the field is `BLOCKED`"]
403 #[inline(always)]
404 pub fn is_blocked(&self) -> bool {
405 **self == PIO0_PIN4_SEC_MASK_A::BLOCKED
406 }
407 #[doc = "Checks if the value of the field is `READABLE`"]
408 #[inline(always)]
409 pub fn is_readable(&self) -> bool {
410 **self == PIO0_PIN4_SEC_MASK_A::READABLE
411 }
412}
413impl core::ops::Deref for PIO0_PIN4_SEC_MASK_R {
414 type Target = crate::FieldReader<bool, PIO0_PIN4_SEC_MASK_A>;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 &self.0
418 }
419}
420#[doc = "Field `PIO0_PIN4_SEC_MASK` writer - Secure mask for pin P0_4"]
421pub struct PIO0_PIN4_SEC_MASK_W<'a> {
422 w: &'a mut W,
423}
424impl<'a> PIO0_PIN4_SEC_MASK_W<'a> {
425 #[doc = r"Writes `variant` to the field"]
426 #[inline(always)]
427 pub fn variant(self, variant: PIO0_PIN4_SEC_MASK_A) -> &'a mut W {
428 self.bit(variant.into())
429 }
430 #[doc = "Pin state is blocked to non-secure world."]
431 #[inline(always)]
432 pub fn blocked(self) -> &'a mut W {
433 self.variant(PIO0_PIN4_SEC_MASK_A::BLOCKED)
434 }
435 #[doc = "Pin state is readable by non-secure world."]
436 #[inline(always)]
437 pub fn readable(self) -> &'a mut W {
438 self.variant(PIO0_PIN4_SEC_MASK_A::READABLE)
439 }
440 #[doc = r"Sets the field bit"]
441 #[inline(always)]
442 pub fn set_bit(self) -> &'a mut W {
443 self.bit(true)
444 }
445 #[doc = r"Clears the field bit"]
446 #[inline(always)]
447 pub fn clear_bit(self) -> &'a mut W {
448 self.bit(false)
449 }
450 #[doc = r"Writes raw bits to the field"]
451 #[inline(always)]
452 pub fn bit(self, value: bool) -> &'a mut W {
453 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
454 self.w
455 }
456}
457#[doc = "Secure mask for pin P0_5\n\nValue on reset: 1"]
458#[derive(Clone, Copy, Debug, PartialEq)]
459pub enum PIO0_PIN5_SEC_MASK_A {
460 #[doc = "0: Pin state is blocked to non-secure world."]
461 BLOCKED = 0,
462 #[doc = "1: Pin state is readable by non-secure world."]
463 READABLE = 1,
464}
465impl From<PIO0_PIN5_SEC_MASK_A> for bool {
466 #[inline(always)]
467 fn from(variant: PIO0_PIN5_SEC_MASK_A) -> Self {
468 variant as u8 != 0
469 }
470}
471#[doc = "Field `PIO0_PIN5_SEC_MASK` reader - Secure mask for pin P0_5"]
472pub struct PIO0_PIN5_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN5_SEC_MASK_A>);
473impl PIO0_PIN5_SEC_MASK_R {
474 #[inline(always)]
475 pub(crate) fn new(bits: bool) -> Self {
476 PIO0_PIN5_SEC_MASK_R(crate::FieldReader::new(bits))
477 }
478 #[doc = r"Get enumerated values variant"]
479 #[inline(always)]
480 pub fn variant(&self) -> PIO0_PIN5_SEC_MASK_A {
481 match self.bits {
482 false => PIO0_PIN5_SEC_MASK_A::BLOCKED,
483 true => PIO0_PIN5_SEC_MASK_A::READABLE,
484 }
485 }
486 #[doc = "Checks if the value of the field is `BLOCKED`"]
487 #[inline(always)]
488 pub fn is_blocked(&self) -> bool {
489 **self == PIO0_PIN5_SEC_MASK_A::BLOCKED
490 }
491 #[doc = "Checks if the value of the field is `READABLE`"]
492 #[inline(always)]
493 pub fn is_readable(&self) -> bool {
494 **self == PIO0_PIN5_SEC_MASK_A::READABLE
495 }
496}
497impl core::ops::Deref for PIO0_PIN5_SEC_MASK_R {
498 type Target = crate::FieldReader<bool, PIO0_PIN5_SEC_MASK_A>;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 &self.0
502 }
503}
504#[doc = "Field `PIO0_PIN5_SEC_MASK` writer - Secure mask for pin P0_5"]
505pub struct PIO0_PIN5_SEC_MASK_W<'a> {
506 w: &'a mut W,
507}
508impl<'a> PIO0_PIN5_SEC_MASK_W<'a> {
509 #[doc = r"Writes `variant` to the field"]
510 #[inline(always)]
511 pub fn variant(self, variant: PIO0_PIN5_SEC_MASK_A) -> &'a mut W {
512 self.bit(variant.into())
513 }
514 #[doc = "Pin state is blocked to non-secure world."]
515 #[inline(always)]
516 pub fn blocked(self) -> &'a mut W {
517 self.variant(PIO0_PIN5_SEC_MASK_A::BLOCKED)
518 }
519 #[doc = "Pin state is readable by non-secure world."]
520 #[inline(always)]
521 pub fn readable(self) -> &'a mut W {
522 self.variant(PIO0_PIN5_SEC_MASK_A::READABLE)
523 }
524 #[doc = r"Sets the field bit"]
525 #[inline(always)]
526 pub fn set_bit(self) -> &'a mut W {
527 self.bit(true)
528 }
529 #[doc = r"Clears the field bit"]
530 #[inline(always)]
531 pub fn clear_bit(self) -> &'a mut W {
532 self.bit(false)
533 }
534 #[doc = r"Writes raw bits to the field"]
535 #[inline(always)]
536 pub fn bit(self, value: bool) -> &'a mut W {
537 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
538 self.w
539 }
540}
541#[doc = "Secure mask for pin P0_6\n\nValue on reset: 1"]
542#[derive(Clone, Copy, Debug, PartialEq)]
543pub enum PIO0_PIN6_SEC_MASK_A {
544 #[doc = "0: Pin state is blocked to non-secure world."]
545 BLOCKED = 0,
546 #[doc = "1: Pin state is readable by non-secure world."]
547 READABLE = 1,
548}
549impl From<PIO0_PIN6_SEC_MASK_A> for bool {
550 #[inline(always)]
551 fn from(variant: PIO0_PIN6_SEC_MASK_A) -> Self {
552 variant as u8 != 0
553 }
554}
555#[doc = "Field `PIO0_PIN6_SEC_MASK` reader - Secure mask for pin P0_6"]
556pub struct PIO0_PIN6_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN6_SEC_MASK_A>);
557impl PIO0_PIN6_SEC_MASK_R {
558 #[inline(always)]
559 pub(crate) fn new(bits: bool) -> Self {
560 PIO0_PIN6_SEC_MASK_R(crate::FieldReader::new(bits))
561 }
562 #[doc = r"Get enumerated values variant"]
563 #[inline(always)]
564 pub fn variant(&self) -> PIO0_PIN6_SEC_MASK_A {
565 match self.bits {
566 false => PIO0_PIN6_SEC_MASK_A::BLOCKED,
567 true => PIO0_PIN6_SEC_MASK_A::READABLE,
568 }
569 }
570 #[doc = "Checks if the value of the field is `BLOCKED`"]
571 #[inline(always)]
572 pub fn is_blocked(&self) -> bool {
573 **self == PIO0_PIN6_SEC_MASK_A::BLOCKED
574 }
575 #[doc = "Checks if the value of the field is `READABLE`"]
576 #[inline(always)]
577 pub fn is_readable(&self) -> bool {
578 **self == PIO0_PIN6_SEC_MASK_A::READABLE
579 }
580}
581impl core::ops::Deref for PIO0_PIN6_SEC_MASK_R {
582 type Target = crate::FieldReader<bool, PIO0_PIN6_SEC_MASK_A>;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 &self.0
586 }
587}
588#[doc = "Field `PIO0_PIN6_SEC_MASK` writer - Secure mask for pin P0_6"]
589pub struct PIO0_PIN6_SEC_MASK_W<'a> {
590 w: &'a mut W,
591}
592impl<'a> PIO0_PIN6_SEC_MASK_W<'a> {
593 #[doc = r"Writes `variant` to the field"]
594 #[inline(always)]
595 pub fn variant(self, variant: PIO0_PIN6_SEC_MASK_A) -> &'a mut W {
596 self.bit(variant.into())
597 }
598 #[doc = "Pin state is blocked to non-secure world."]
599 #[inline(always)]
600 pub fn blocked(self) -> &'a mut W {
601 self.variant(PIO0_PIN6_SEC_MASK_A::BLOCKED)
602 }
603 #[doc = "Pin state is readable by non-secure world."]
604 #[inline(always)]
605 pub fn readable(self) -> &'a mut W {
606 self.variant(PIO0_PIN6_SEC_MASK_A::READABLE)
607 }
608 #[doc = r"Sets the field bit"]
609 #[inline(always)]
610 pub fn set_bit(self) -> &'a mut W {
611 self.bit(true)
612 }
613 #[doc = r"Clears the field bit"]
614 #[inline(always)]
615 pub fn clear_bit(self) -> &'a mut W {
616 self.bit(false)
617 }
618 #[doc = r"Writes raw bits to the field"]
619 #[inline(always)]
620 pub fn bit(self, value: bool) -> &'a mut W {
621 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
622 self.w
623 }
624}
625#[doc = "Secure mask for pin P0_7\n\nValue on reset: 1"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum PIO0_PIN7_SEC_MASK_A {
628 #[doc = "0: Pin state is blocked to non-secure world."]
629 BLOCKED = 0,
630 #[doc = "1: Pin state is readable by non-secure world."]
631 READABLE = 1,
632}
633impl From<PIO0_PIN7_SEC_MASK_A> for bool {
634 #[inline(always)]
635 fn from(variant: PIO0_PIN7_SEC_MASK_A) -> Self {
636 variant as u8 != 0
637 }
638}
639#[doc = "Field `PIO0_PIN7_SEC_MASK` reader - Secure mask for pin P0_7"]
640pub struct PIO0_PIN7_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN7_SEC_MASK_A>);
641impl PIO0_PIN7_SEC_MASK_R {
642 #[inline(always)]
643 pub(crate) fn new(bits: bool) -> Self {
644 PIO0_PIN7_SEC_MASK_R(crate::FieldReader::new(bits))
645 }
646 #[doc = r"Get enumerated values variant"]
647 #[inline(always)]
648 pub fn variant(&self) -> PIO0_PIN7_SEC_MASK_A {
649 match self.bits {
650 false => PIO0_PIN7_SEC_MASK_A::BLOCKED,
651 true => PIO0_PIN7_SEC_MASK_A::READABLE,
652 }
653 }
654 #[doc = "Checks if the value of the field is `BLOCKED`"]
655 #[inline(always)]
656 pub fn is_blocked(&self) -> bool {
657 **self == PIO0_PIN7_SEC_MASK_A::BLOCKED
658 }
659 #[doc = "Checks if the value of the field is `READABLE`"]
660 #[inline(always)]
661 pub fn is_readable(&self) -> bool {
662 **self == PIO0_PIN7_SEC_MASK_A::READABLE
663 }
664}
665impl core::ops::Deref for PIO0_PIN7_SEC_MASK_R {
666 type Target = crate::FieldReader<bool, PIO0_PIN7_SEC_MASK_A>;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 &self.0
670 }
671}
672#[doc = "Field `PIO0_PIN7_SEC_MASK` writer - Secure mask for pin P0_7"]
673pub struct PIO0_PIN7_SEC_MASK_W<'a> {
674 w: &'a mut W,
675}
676impl<'a> PIO0_PIN7_SEC_MASK_W<'a> {
677 #[doc = r"Writes `variant` to the field"]
678 #[inline(always)]
679 pub fn variant(self, variant: PIO0_PIN7_SEC_MASK_A) -> &'a mut W {
680 self.bit(variant.into())
681 }
682 #[doc = "Pin state is blocked to non-secure world."]
683 #[inline(always)]
684 pub fn blocked(self) -> &'a mut W {
685 self.variant(PIO0_PIN7_SEC_MASK_A::BLOCKED)
686 }
687 #[doc = "Pin state is readable by non-secure world."]
688 #[inline(always)]
689 pub fn readable(self) -> &'a mut W {
690 self.variant(PIO0_PIN7_SEC_MASK_A::READABLE)
691 }
692 #[doc = r"Sets the field bit"]
693 #[inline(always)]
694 pub fn set_bit(self) -> &'a mut W {
695 self.bit(true)
696 }
697 #[doc = r"Clears the field bit"]
698 #[inline(always)]
699 pub fn clear_bit(self) -> &'a mut W {
700 self.bit(false)
701 }
702 #[doc = r"Writes raw bits to the field"]
703 #[inline(always)]
704 pub fn bit(self, value: bool) -> &'a mut W {
705 self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
706 self.w
707 }
708}
709#[doc = "Secure mask for pin P0_8\n\nValue on reset: 1"]
710#[derive(Clone, Copy, Debug, PartialEq)]
711pub enum PIO0_PIN8_SEC_MASK_A {
712 #[doc = "0: Pin state is blocked to non-secure world."]
713 BLOCKED = 0,
714 #[doc = "1: Pin state is readable by non-secure world."]
715 READABLE = 1,
716}
717impl From<PIO0_PIN8_SEC_MASK_A> for bool {
718 #[inline(always)]
719 fn from(variant: PIO0_PIN8_SEC_MASK_A) -> Self {
720 variant as u8 != 0
721 }
722}
723#[doc = "Field `PIO0_PIN8_SEC_MASK` reader - Secure mask for pin P0_8"]
724pub struct PIO0_PIN8_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN8_SEC_MASK_A>);
725impl PIO0_PIN8_SEC_MASK_R {
726 #[inline(always)]
727 pub(crate) fn new(bits: bool) -> Self {
728 PIO0_PIN8_SEC_MASK_R(crate::FieldReader::new(bits))
729 }
730 #[doc = r"Get enumerated values variant"]
731 #[inline(always)]
732 pub fn variant(&self) -> PIO0_PIN8_SEC_MASK_A {
733 match self.bits {
734 false => PIO0_PIN8_SEC_MASK_A::BLOCKED,
735 true => PIO0_PIN8_SEC_MASK_A::READABLE,
736 }
737 }
738 #[doc = "Checks if the value of the field is `BLOCKED`"]
739 #[inline(always)]
740 pub fn is_blocked(&self) -> bool {
741 **self == PIO0_PIN8_SEC_MASK_A::BLOCKED
742 }
743 #[doc = "Checks if the value of the field is `READABLE`"]
744 #[inline(always)]
745 pub fn is_readable(&self) -> bool {
746 **self == PIO0_PIN8_SEC_MASK_A::READABLE
747 }
748}
749impl core::ops::Deref for PIO0_PIN8_SEC_MASK_R {
750 type Target = crate::FieldReader<bool, PIO0_PIN8_SEC_MASK_A>;
751 #[inline(always)]
752 fn deref(&self) -> &Self::Target {
753 &self.0
754 }
755}
756#[doc = "Field `PIO0_PIN8_SEC_MASK` writer - Secure mask for pin P0_8"]
757pub struct PIO0_PIN8_SEC_MASK_W<'a> {
758 w: &'a mut W,
759}
760impl<'a> PIO0_PIN8_SEC_MASK_W<'a> {
761 #[doc = r"Writes `variant` to the field"]
762 #[inline(always)]
763 pub fn variant(self, variant: PIO0_PIN8_SEC_MASK_A) -> &'a mut W {
764 self.bit(variant.into())
765 }
766 #[doc = "Pin state is blocked to non-secure world."]
767 #[inline(always)]
768 pub fn blocked(self) -> &'a mut W {
769 self.variant(PIO0_PIN8_SEC_MASK_A::BLOCKED)
770 }
771 #[doc = "Pin state is readable by non-secure world."]
772 #[inline(always)]
773 pub fn readable(self) -> &'a mut W {
774 self.variant(PIO0_PIN8_SEC_MASK_A::READABLE)
775 }
776 #[doc = r"Sets the field bit"]
777 #[inline(always)]
778 pub fn set_bit(self) -> &'a mut W {
779 self.bit(true)
780 }
781 #[doc = r"Clears the field bit"]
782 #[inline(always)]
783 pub fn clear_bit(self) -> &'a mut W {
784 self.bit(false)
785 }
786 #[doc = r"Writes raw bits to the field"]
787 #[inline(always)]
788 pub fn bit(self, value: bool) -> &'a mut W {
789 self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
790 self.w
791 }
792}
793#[doc = "Secure mask for pin P0_9\n\nValue on reset: 1"]
794#[derive(Clone, Copy, Debug, PartialEq)]
795pub enum PIO0_PIN9_SEC_MASK_A {
796 #[doc = "0: Pin state is blocked to non-secure world."]
797 BLOCKED = 0,
798 #[doc = "1: Pin state is readable by non-secure world."]
799 READABLE = 1,
800}
801impl From<PIO0_PIN9_SEC_MASK_A> for bool {
802 #[inline(always)]
803 fn from(variant: PIO0_PIN9_SEC_MASK_A) -> Self {
804 variant as u8 != 0
805 }
806}
807#[doc = "Field `PIO0_PIN9_SEC_MASK` reader - Secure mask for pin P0_9"]
808pub struct PIO0_PIN9_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN9_SEC_MASK_A>);
809impl PIO0_PIN9_SEC_MASK_R {
810 #[inline(always)]
811 pub(crate) fn new(bits: bool) -> Self {
812 PIO0_PIN9_SEC_MASK_R(crate::FieldReader::new(bits))
813 }
814 #[doc = r"Get enumerated values variant"]
815 #[inline(always)]
816 pub fn variant(&self) -> PIO0_PIN9_SEC_MASK_A {
817 match self.bits {
818 false => PIO0_PIN9_SEC_MASK_A::BLOCKED,
819 true => PIO0_PIN9_SEC_MASK_A::READABLE,
820 }
821 }
822 #[doc = "Checks if the value of the field is `BLOCKED`"]
823 #[inline(always)]
824 pub fn is_blocked(&self) -> bool {
825 **self == PIO0_PIN9_SEC_MASK_A::BLOCKED
826 }
827 #[doc = "Checks if the value of the field is `READABLE`"]
828 #[inline(always)]
829 pub fn is_readable(&self) -> bool {
830 **self == PIO0_PIN9_SEC_MASK_A::READABLE
831 }
832}
833impl core::ops::Deref for PIO0_PIN9_SEC_MASK_R {
834 type Target = crate::FieldReader<bool, PIO0_PIN9_SEC_MASK_A>;
835 #[inline(always)]
836 fn deref(&self) -> &Self::Target {
837 &self.0
838 }
839}
840#[doc = "Field `PIO0_PIN9_SEC_MASK` writer - Secure mask for pin P0_9"]
841pub struct PIO0_PIN9_SEC_MASK_W<'a> {
842 w: &'a mut W,
843}
844impl<'a> PIO0_PIN9_SEC_MASK_W<'a> {
845 #[doc = r"Writes `variant` to the field"]
846 #[inline(always)]
847 pub fn variant(self, variant: PIO0_PIN9_SEC_MASK_A) -> &'a mut W {
848 self.bit(variant.into())
849 }
850 #[doc = "Pin state is blocked to non-secure world."]
851 #[inline(always)]
852 pub fn blocked(self) -> &'a mut W {
853 self.variant(PIO0_PIN9_SEC_MASK_A::BLOCKED)
854 }
855 #[doc = "Pin state is readable by non-secure world."]
856 #[inline(always)]
857 pub fn readable(self) -> &'a mut W {
858 self.variant(PIO0_PIN9_SEC_MASK_A::READABLE)
859 }
860 #[doc = r"Sets the field bit"]
861 #[inline(always)]
862 pub fn set_bit(self) -> &'a mut W {
863 self.bit(true)
864 }
865 #[doc = r"Clears the field bit"]
866 #[inline(always)]
867 pub fn clear_bit(self) -> &'a mut W {
868 self.bit(false)
869 }
870 #[doc = r"Writes raw bits to the field"]
871 #[inline(always)]
872 pub fn bit(self, value: bool) -> &'a mut W {
873 self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
874 self.w
875 }
876}
877#[doc = "Secure mask for pin P0_10\n\nValue on reset: 1"]
878#[derive(Clone, Copy, Debug, PartialEq)]
879pub enum PIO0_PIN10_SEC_MASK_A {
880 #[doc = "0: Pin state is blocked to non-secure world."]
881 BLOCKED = 0,
882 #[doc = "1: Pin state is readable by non-secure world."]
883 READABLE = 1,
884}
885impl From<PIO0_PIN10_SEC_MASK_A> for bool {
886 #[inline(always)]
887 fn from(variant: PIO0_PIN10_SEC_MASK_A) -> Self {
888 variant as u8 != 0
889 }
890}
891#[doc = "Field `PIO0_PIN10_SEC_MASK` reader - Secure mask for pin P0_10"]
892pub struct PIO0_PIN10_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN10_SEC_MASK_A>);
893impl PIO0_PIN10_SEC_MASK_R {
894 #[inline(always)]
895 pub(crate) fn new(bits: bool) -> Self {
896 PIO0_PIN10_SEC_MASK_R(crate::FieldReader::new(bits))
897 }
898 #[doc = r"Get enumerated values variant"]
899 #[inline(always)]
900 pub fn variant(&self) -> PIO0_PIN10_SEC_MASK_A {
901 match self.bits {
902 false => PIO0_PIN10_SEC_MASK_A::BLOCKED,
903 true => PIO0_PIN10_SEC_MASK_A::READABLE,
904 }
905 }
906 #[doc = "Checks if the value of the field is `BLOCKED`"]
907 #[inline(always)]
908 pub fn is_blocked(&self) -> bool {
909 **self == PIO0_PIN10_SEC_MASK_A::BLOCKED
910 }
911 #[doc = "Checks if the value of the field is `READABLE`"]
912 #[inline(always)]
913 pub fn is_readable(&self) -> bool {
914 **self == PIO0_PIN10_SEC_MASK_A::READABLE
915 }
916}
917impl core::ops::Deref for PIO0_PIN10_SEC_MASK_R {
918 type Target = crate::FieldReader<bool, PIO0_PIN10_SEC_MASK_A>;
919 #[inline(always)]
920 fn deref(&self) -> &Self::Target {
921 &self.0
922 }
923}
924#[doc = "Field `PIO0_PIN10_SEC_MASK` writer - Secure mask for pin P0_10"]
925pub struct PIO0_PIN10_SEC_MASK_W<'a> {
926 w: &'a mut W,
927}
928impl<'a> PIO0_PIN10_SEC_MASK_W<'a> {
929 #[doc = r"Writes `variant` to the field"]
930 #[inline(always)]
931 pub fn variant(self, variant: PIO0_PIN10_SEC_MASK_A) -> &'a mut W {
932 self.bit(variant.into())
933 }
934 #[doc = "Pin state is blocked to non-secure world."]
935 #[inline(always)]
936 pub fn blocked(self) -> &'a mut W {
937 self.variant(PIO0_PIN10_SEC_MASK_A::BLOCKED)
938 }
939 #[doc = "Pin state is readable by non-secure world."]
940 #[inline(always)]
941 pub fn readable(self) -> &'a mut W {
942 self.variant(PIO0_PIN10_SEC_MASK_A::READABLE)
943 }
944 #[doc = r"Sets the field bit"]
945 #[inline(always)]
946 pub fn set_bit(self) -> &'a mut W {
947 self.bit(true)
948 }
949 #[doc = r"Clears the field bit"]
950 #[inline(always)]
951 pub fn clear_bit(self) -> &'a mut W {
952 self.bit(false)
953 }
954 #[doc = r"Writes raw bits to the field"]
955 #[inline(always)]
956 pub fn bit(self, value: bool) -> &'a mut W {
957 self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
958 self.w
959 }
960}
961#[doc = "Secure mask for pin P0_11\n\nValue on reset: 1"]
962#[derive(Clone, Copy, Debug, PartialEq)]
963pub enum PIO0_PIN11_SEC_MASK_A {
964 #[doc = "0: Pin state is blocked to non-secure world."]
965 BLOCKED = 0,
966 #[doc = "1: Pin state is readable by non-secure world."]
967 READABLE = 1,
968}
969impl From<PIO0_PIN11_SEC_MASK_A> for bool {
970 #[inline(always)]
971 fn from(variant: PIO0_PIN11_SEC_MASK_A) -> Self {
972 variant as u8 != 0
973 }
974}
975#[doc = "Field `PIO0_PIN11_SEC_MASK` reader - Secure mask for pin P0_11"]
976pub struct PIO0_PIN11_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN11_SEC_MASK_A>);
977impl PIO0_PIN11_SEC_MASK_R {
978 #[inline(always)]
979 pub(crate) fn new(bits: bool) -> Self {
980 PIO0_PIN11_SEC_MASK_R(crate::FieldReader::new(bits))
981 }
982 #[doc = r"Get enumerated values variant"]
983 #[inline(always)]
984 pub fn variant(&self) -> PIO0_PIN11_SEC_MASK_A {
985 match self.bits {
986 false => PIO0_PIN11_SEC_MASK_A::BLOCKED,
987 true => PIO0_PIN11_SEC_MASK_A::READABLE,
988 }
989 }
990 #[doc = "Checks if the value of the field is `BLOCKED`"]
991 #[inline(always)]
992 pub fn is_blocked(&self) -> bool {
993 **self == PIO0_PIN11_SEC_MASK_A::BLOCKED
994 }
995 #[doc = "Checks if the value of the field is `READABLE`"]
996 #[inline(always)]
997 pub fn is_readable(&self) -> bool {
998 **self == PIO0_PIN11_SEC_MASK_A::READABLE
999 }
1000}
1001impl core::ops::Deref for PIO0_PIN11_SEC_MASK_R {
1002 type Target = crate::FieldReader<bool, PIO0_PIN11_SEC_MASK_A>;
1003 #[inline(always)]
1004 fn deref(&self) -> &Self::Target {
1005 &self.0
1006 }
1007}
1008#[doc = "Field `PIO0_PIN11_SEC_MASK` writer - Secure mask for pin P0_11"]
1009pub struct PIO0_PIN11_SEC_MASK_W<'a> {
1010 w: &'a mut W,
1011}
1012impl<'a> PIO0_PIN11_SEC_MASK_W<'a> {
1013 #[doc = r"Writes `variant` to the field"]
1014 #[inline(always)]
1015 pub fn variant(self, variant: PIO0_PIN11_SEC_MASK_A) -> &'a mut W {
1016 self.bit(variant.into())
1017 }
1018 #[doc = "Pin state is blocked to non-secure world."]
1019 #[inline(always)]
1020 pub fn blocked(self) -> &'a mut W {
1021 self.variant(PIO0_PIN11_SEC_MASK_A::BLOCKED)
1022 }
1023 #[doc = "Pin state is readable by non-secure world."]
1024 #[inline(always)]
1025 pub fn readable(self) -> &'a mut W {
1026 self.variant(PIO0_PIN11_SEC_MASK_A::READABLE)
1027 }
1028 #[doc = r"Sets the field bit"]
1029 #[inline(always)]
1030 pub fn set_bit(self) -> &'a mut W {
1031 self.bit(true)
1032 }
1033 #[doc = r"Clears the field bit"]
1034 #[inline(always)]
1035 pub fn clear_bit(self) -> &'a mut W {
1036 self.bit(false)
1037 }
1038 #[doc = r"Writes raw bits to the field"]
1039 #[inline(always)]
1040 pub fn bit(self, value: bool) -> &'a mut W {
1041 self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
1042 self.w
1043 }
1044}
1045#[doc = "Secure mask for pin P0_12\n\nValue on reset: 1"]
1046#[derive(Clone, Copy, Debug, PartialEq)]
1047pub enum PIO0_PIN12_SEC_MASK_A {
1048 #[doc = "0: Pin state is blocked to non-secure world."]
1049 BLOCKED = 0,
1050 #[doc = "1: Pin state is readable by non-secure world."]
1051 READABLE = 1,
1052}
1053impl From<PIO0_PIN12_SEC_MASK_A> for bool {
1054 #[inline(always)]
1055 fn from(variant: PIO0_PIN12_SEC_MASK_A) -> Self {
1056 variant as u8 != 0
1057 }
1058}
1059#[doc = "Field `PIO0_PIN12_SEC_MASK` reader - Secure mask for pin P0_12"]
1060pub struct PIO0_PIN12_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN12_SEC_MASK_A>);
1061impl PIO0_PIN12_SEC_MASK_R {
1062 #[inline(always)]
1063 pub(crate) fn new(bits: bool) -> Self {
1064 PIO0_PIN12_SEC_MASK_R(crate::FieldReader::new(bits))
1065 }
1066 #[doc = r"Get enumerated values variant"]
1067 #[inline(always)]
1068 pub fn variant(&self) -> PIO0_PIN12_SEC_MASK_A {
1069 match self.bits {
1070 false => PIO0_PIN12_SEC_MASK_A::BLOCKED,
1071 true => PIO0_PIN12_SEC_MASK_A::READABLE,
1072 }
1073 }
1074 #[doc = "Checks if the value of the field is `BLOCKED`"]
1075 #[inline(always)]
1076 pub fn is_blocked(&self) -> bool {
1077 **self == PIO0_PIN12_SEC_MASK_A::BLOCKED
1078 }
1079 #[doc = "Checks if the value of the field is `READABLE`"]
1080 #[inline(always)]
1081 pub fn is_readable(&self) -> bool {
1082 **self == PIO0_PIN12_SEC_MASK_A::READABLE
1083 }
1084}
1085impl core::ops::Deref for PIO0_PIN12_SEC_MASK_R {
1086 type Target = crate::FieldReader<bool, PIO0_PIN12_SEC_MASK_A>;
1087 #[inline(always)]
1088 fn deref(&self) -> &Self::Target {
1089 &self.0
1090 }
1091}
1092#[doc = "Field `PIO0_PIN12_SEC_MASK` writer - Secure mask for pin P0_12"]
1093pub struct PIO0_PIN12_SEC_MASK_W<'a> {
1094 w: &'a mut W,
1095}
1096impl<'a> PIO0_PIN12_SEC_MASK_W<'a> {
1097 #[doc = r"Writes `variant` to the field"]
1098 #[inline(always)]
1099 pub fn variant(self, variant: PIO0_PIN12_SEC_MASK_A) -> &'a mut W {
1100 self.bit(variant.into())
1101 }
1102 #[doc = "Pin state is blocked to non-secure world."]
1103 #[inline(always)]
1104 pub fn blocked(self) -> &'a mut W {
1105 self.variant(PIO0_PIN12_SEC_MASK_A::BLOCKED)
1106 }
1107 #[doc = "Pin state is readable by non-secure world."]
1108 #[inline(always)]
1109 pub fn readable(self) -> &'a mut W {
1110 self.variant(PIO0_PIN12_SEC_MASK_A::READABLE)
1111 }
1112 #[doc = r"Sets the field bit"]
1113 #[inline(always)]
1114 pub fn set_bit(self) -> &'a mut W {
1115 self.bit(true)
1116 }
1117 #[doc = r"Clears the field bit"]
1118 #[inline(always)]
1119 pub fn clear_bit(self) -> &'a mut W {
1120 self.bit(false)
1121 }
1122 #[doc = r"Writes raw bits to the field"]
1123 #[inline(always)]
1124 pub fn bit(self, value: bool) -> &'a mut W {
1125 self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
1126 self.w
1127 }
1128}
1129#[doc = "Secure mask for pin P0_13\n\nValue on reset: 1"]
1130#[derive(Clone, Copy, Debug, PartialEq)]
1131pub enum PIO0_PIN13_SEC_MASK_A {
1132 #[doc = "0: Pin state is blocked to non-secure world."]
1133 BLOCKED = 0,
1134 #[doc = "1: Pin state is readable by non-secure world."]
1135 READABLE = 1,
1136}
1137impl From<PIO0_PIN13_SEC_MASK_A> for bool {
1138 #[inline(always)]
1139 fn from(variant: PIO0_PIN13_SEC_MASK_A) -> Self {
1140 variant as u8 != 0
1141 }
1142}
1143#[doc = "Field `PIO0_PIN13_SEC_MASK` reader - Secure mask for pin P0_13"]
1144pub struct PIO0_PIN13_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN13_SEC_MASK_A>);
1145impl PIO0_PIN13_SEC_MASK_R {
1146 #[inline(always)]
1147 pub(crate) fn new(bits: bool) -> Self {
1148 PIO0_PIN13_SEC_MASK_R(crate::FieldReader::new(bits))
1149 }
1150 #[doc = r"Get enumerated values variant"]
1151 #[inline(always)]
1152 pub fn variant(&self) -> PIO0_PIN13_SEC_MASK_A {
1153 match self.bits {
1154 false => PIO0_PIN13_SEC_MASK_A::BLOCKED,
1155 true => PIO0_PIN13_SEC_MASK_A::READABLE,
1156 }
1157 }
1158 #[doc = "Checks if the value of the field is `BLOCKED`"]
1159 #[inline(always)]
1160 pub fn is_blocked(&self) -> bool {
1161 **self == PIO0_PIN13_SEC_MASK_A::BLOCKED
1162 }
1163 #[doc = "Checks if the value of the field is `READABLE`"]
1164 #[inline(always)]
1165 pub fn is_readable(&self) -> bool {
1166 **self == PIO0_PIN13_SEC_MASK_A::READABLE
1167 }
1168}
1169impl core::ops::Deref for PIO0_PIN13_SEC_MASK_R {
1170 type Target = crate::FieldReader<bool, PIO0_PIN13_SEC_MASK_A>;
1171 #[inline(always)]
1172 fn deref(&self) -> &Self::Target {
1173 &self.0
1174 }
1175}
1176#[doc = "Field `PIO0_PIN13_SEC_MASK` writer - Secure mask for pin P0_13"]
1177pub struct PIO0_PIN13_SEC_MASK_W<'a> {
1178 w: &'a mut W,
1179}
1180impl<'a> PIO0_PIN13_SEC_MASK_W<'a> {
1181 #[doc = r"Writes `variant` to the field"]
1182 #[inline(always)]
1183 pub fn variant(self, variant: PIO0_PIN13_SEC_MASK_A) -> &'a mut W {
1184 self.bit(variant.into())
1185 }
1186 #[doc = "Pin state is blocked to non-secure world."]
1187 #[inline(always)]
1188 pub fn blocked(self) -> &'a mut W {
1189 self.variant(PIO0_PIN13_SEC_MASK_A::BLOCKED)
1190 }
1191 #[doc = "Pin state is readable by non-secure world."]
1192 #[inline(always)]
1193 pub fn readable(self) -> &'a mut W {
1194 self.variant(PIO0_PIN13_SEC_MASK_A::READABLE)
1195 }
1196 #[doc = r"Sets the field bit"]
1197 #[inline(always)]
1198 pub fn set_bit(self) -> &'a mut W {
1199 self.bit(true)
1200 }
1201 #[doc = r"Clears the field bit"]
1202 #[inline(always)]
1203 pub fn clear_bit(self) -> &'a mut W {
1204 self.bit(false)
1205 }
1206 #[doc = r"Writes raw bits to the field"]
1207 #[inline(always)]
1208 pub fn bit(self, value: bool) -> &'a mut W {
1209 self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
1210 self.w
1211 }
1212}
1213#[doc = "Secure mask for pin P0_14\n\nValue on reset: 1"]
1214#[derive(Clone, Copy, Debug, PartialEq)]
1215pub enum PIO0_PIN14_SEC_MASK_A {
1216 #[doc = "0: Pin state is blocked to non-secure world."]
1217 BLOCKED = 0,
1218 #[doc = "1: Pin state is readable by non-secure world."]
1219 READABLE = 1,
1220}
1221impl From<PIO0_PIN14_SEC_MASK_A> for bool {
1222 #[inline(always)]
1223 fn from(variant: PIO0_PIN14_SEC_MASK_A) -> Self {
1224 variant as u8 != 0
1225 }
1226}
1227#[doc = "Field `PIO0_PIN14_SEC_MASK` reader - Secure mask for pin P0_14"]
1228pub struct PIO0_PIN14_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN14_SEC_MASK_A>);
1229impl PIO0_PIN14_SEC_MASK_R {
1230 #[inline(always)]
1231 pub(crate) fn new(bits: bool) -> Self {
1232 PIO0_PIN14_SEC_MASK_R(crate::FieldReader::new(bits))
1233 }
1234 #[doc = r"Get enumerated values variant"]
1235 #[inline(always)]
1236 pub fn variant(&self) -> PIO0_PIN14_SEC_MASK_A {
1237 match self.bits {
1238 false => PIO0_PIN14_SEC_MASK_A::BLOCKED,
1239 true => PIO0_PIN14_SEC_MASK_A::READABLE,
1240 }
1241 }
1242 #[doc = "Checks if the value of the field is `BLOCKED`"]
1243 #[inline(always)]
1244 pub fn is_blocked(&self) -> bool {
1245 **self == PIO0_PIN14_SEC_MASK_A::BLOCKED
1246 }
1247 #[doc = "Checks if the value of the field is `READABLE`"]
1248 #[inline(always)]
1249 pub fn is_readable(&self) -> bool {
1250 **self == PIO0_PIN14_SEC_MASK_A::READABLE
1251 }
1252}
1253impl core::ops::Deref for PIO0_PIN14_SEC_MASK_R {
1254 type Target = crate::FieldReader<bool, PIO0_PIN14_SEC_MASK_A>;
1255 #[inline(always)]
1256 fn deref(&self) -> &Self::Target {
1257 &self.0
1258 }
1259}
1260#[doc = "Field `PIO0_PIN14_SEC_MASK` writer - Secure mask for pin P0_14"]
1261pub struct PIO0_PIN14_SEC_MASK_W<'a> {
1262 w: &'a mut W,
1263}
1264impl<'a> PIO0_PIN14_SEC_MASK_W<'a> {
1265 #[doc = r"Writes `variant` to the field"]
1266 #[inline(always)]
1267 pub fn variant(self, variant: PIO0_PIN14_SEC_MASK_A) -> &'a mut W {
1268 self.bit(variant.into())
1269 }
1270 #[doc = "Pin state is blocked to non-secure world."]
1271 #[inline(always)]
1272 pub fn blocked(self) -> &'a mut W {
1273 self.variant(PIO0_PIN14_SEC_MASK_A::BLOCKED)
1274 }
1275 #[doc = "Pin state is readable by non-secure world."]
1276 #[inline(always)]
1277 pub fn readable(self) -> &'a mut W {
1278 self.variant(PIO0_PIN14_SEC_MASK_A::READABLE)
1279 }
1280 #[doc = r"Sets the field bit"]
1281 #[inline(always)]
1282 pub fn set_bit(self) -> &'a mut W {
1283 self.bit(true)
1284 }
1285 #[doc = r"Clears the field bit"]
1286 #[inline(always)]
1287 pub fn clear_bit(self) -> &'a mut W {
1288 self.bit(false)
1289 }
1290 #[doc = r"Writes raw bits to the field"]
1291 #[inline(always)]
1292 pub fn bit(self, value: bool) -> &'a mut W {
1293 self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
1294 self.w
1295 }
1296}
1297#[doc = "Secure mask for pin P0_15\n\nValue on reset: 1"]
1298#[derive(Clone, Copy, Debug, PartialEq)]
1299pub enum PIO0_PIN15_SEC_MASK_A {
1300 #[doc = "0: Pin state is blocked to non-secure world."]
1301 BLOCKED = 0,
1302 #[doc = "1: Pin state is readable by non-secure world."]
1303 READABLE = 1,
1304}
1305impl From<PIO0_PIN15_SEC_MASK_A> for bool {
1306 #[inline(always)]
1307 fn from(variant: PIO0_PIN15_SEC_MASK_A) -> Self {
1308 variant as u8 != 0
1309 }
1310}
1311#[doc = "Field `PIO0_PIN15_SEC_MASK` reader - Secure mask for pin P0_15"]
1312pub struct PIO0_PIN15_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN15_SEC_MASK_A>);
1313impl PIO0_PIN15_SEC_MASK_R {
1314 #[inline(always)]
1315 pub(crate) fn new(bits: bool) -> Self {
1316 PIO0_PIN15_SEC_MASK_R(crate::FieldReader::new(bits))
1317 }
1318 #[doc = r"Get enumerated values variant"]
1319 #[inline(always)]
1320 pub fn variant(&self) -> PIO0_PIN15_SEC_MASK_A {
1321 match self.bits {
1322 false => PIO0_PIN15_SEC_MASK_A::BLOCKED,
1323 true => PIO0_PIN15_SEC_MASK_A::READABLE,
1324 }
1325 }
1326 #[doc = "Checks if the value of the field is `BLOCKED`"]
1327 #[inline(always)]
1328 pub fn is_blocked(&self) -> bool {
1329 **self == PIO0_PIN15_SEC_MASK_A::BLOCKED
1330 }
1331 #[doc = "Checks if the value of the field is `READABLE`"]
1332 #[inline(always)]
1333 pub fn is_readable(&self) -> bool {
1334 **self == PIO0_PIN15_SEC_MASK_A::READABLE
1335 }
1336}
1337impl core::ops::Deref for PIO0_PIN15_SEC_MASK_R {
1338 type Target = crate::FieldReader<bool, PIO0_PIN15_SEC_MASK_A>;
1339 #[inline(always)]
1340 fn deref(&self) -> &Self::Target {
1341 &self.0
1342 }
1343}
1344#[doc = "Field `PIO0_PIN15_SEC_MASK` writer - Secure mask for pin P0_15"]
1345pub struct PIO0_PIN15_SEC_MASK_W<'a> {
1346 w: &'a mut W,
1347}
1348impl<'a> PIO0_PIN15_SEC_MASK_W<'a> {
1349 #[doc = r"Writes `variant` to the field"]
1350 #[inline(always)]
1351 pub fn variant(self, variant: PIO0_PIN15_SEC_MASK_A) -> &'a mut W {
1352 self.bit(variant.into())
1353 }
1354 #[doc = "Pin state is blocked to non-secure world."]
1355 #[inline(always)]
1356 pub fn blocked(self) -> &'a mut W {
1357 self.variant(PIO0_PIN15_SEC_MASK_A::BLOCKED)
1358 }
1359 #[doc = "Pin state is readable by non-secure world."]
1360 #[inline(always)]
1361 pub fn readable(self) -> &'a mut W {
1362 self.variant(PIO0_PIN15_SEC_MASK_A::READABLE)
1363 }
1364 #[doc = r"Sets the field bit"]
1365 #[inline(always)]
1366 pub fn set_bit(self) -> &'a mut W {
1367 self.bit(true)
1368 }
1369 #[doc = r"Clears the field bit"]
1370 #[inline(always)]
1371 pub fn clear_bit(self) -> &'a mut W {
1372 self.bit(false)
1373 }
1374 #[doc = r"Writes raw bits to the field"]
1375 #[inline(always)]
1376 pub fn bit(self, value: bool) -> &'a mut W {
1377 self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
1378 self.w
1379 }
1380}
1381#[doc = "Secure mask for pin P0_16\n\nValue on reset: 1"]
1382#[derive(Clone, Copy, Debug, PartialEq)]
1383pub enum PIO0_PIN16_SEC_MASK_A {
1384 #[doc = "0: Pin state is blocked to non-secure world."]
1385 BLOCKED = 0,
1386 #[doc = "1: Pin state is readable by non-secure world."]
1387 READABLE = 1,
1388}
1389impl From<PIO0_PIN16_SEC_MASK_A> for bool {
1390 #[inline(always)]
1391 fn from(variant: PIO0_PIN16_SEC_MASK_A) -> Self {
1392 variant as u8 != 0
1393 }
1394}
1395#[doc = "Field `PIO0_PIN16_SEC_MASK` reader - Secure mask for pin P0_16"]
1396pub struct PIO0_PIN16_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN16_SEC_MASK_A>);
1397impl PIO0_PIN16_SEC_MASK_R {
1398 #[inline(always)]
1399 pub(crate) fn new(bits: bool) -> Self {
1400 PIO0_PIN16_SEC_MASK_R(crate::FieldReader::new(bits))
1401 }
1402 #[doc = r"Get enumerated values variant"]
1403 #[inline(always)]
1404 pub fn variant(&self) -> PIO0_PIN16_SEC_MASK_A {
1405 match self.bits {
1406 false => PIO0_PIN16_SEC_MASK_A::BLOCKED,
1407 true => PIO0_PIN16_SEC_MASK_A::READABLE,
1408 }
1409 }
1410 #[doc = "Checks if the value of the field is `BLOCKED`"]
1411 #[inline(always)]
1412 pub fn is_blocked(&self) -> bool {
1413 **self == PIO0_PIN16_SEC_MASK_A::BLOCKED
1414 }
1415 #[doc = "Checks if the value of the field is `READABLE`"]
1416 #[inline(always)]
1417 pub fn is_readable(&self) -> bool {
1418 **self == PIO0_PIN16_SEC_MASK_A::READABLE
1419 }
1420}
1421impl core::ops::Deref for PIO0_PIN16_SEC_MASK_R {
1422 type Target = crate::FieldReader<bool, PIO0_PIN16_SEC_MASK_A>;
1423 #[inline(always)]
1424 fn deref(&self) -> &Self::Target {
1425 &self.0
1426 }
1427}
1428#[doc = "Field `PIO0_PIN16_SEC_MASK` writer - Secure mask for pin P0_16"]
1429pub struct PIO0_PIN16_SEC_MASK_W<'a> {
1430 w: &'a mut W,
1431}
1432impl<'a> PIO0_PIN16_SEC_MASK_W<'a> {
1433 #[doc = r"Writes `variant` to the field"]
1434 #[inline(always)]
1435 pub fn variant(self, variant: PIO0_PIN16_SEC_MASK_A) -> &'a mut W {
1436 self.bit(variant.into())
1437 }
1438 #[doc = "Pin state is blocked to non-secure world."]
1439 #[inline(always)]
1440 pub fn blocked(self) -> &'a mut W {
1441 self.variant(PIO0_PIN16_SEC_MASK_A::BLOCKED)
1442 }
1443 #[doc = "Pin state is readable by non-secure world."]
1444 #[inline(always)]
1445 pub fn readable(self) -> &'a mut W {
1446 self.variant(PIO0_PIN16_SEC_MASK_A::READABLE)
1447 }
1448 #[doc = r"Sets the field bit"]
1449 #[inline(always)]
1450 pub fn set_bit(self) -> &'a mut W {
1451 self.bit(true)
1452 }
1453 #[doc = r"Clears the field bit"]
1454 #[inline(always)]
1455 pub fn clear_bit(self) -> &'a mut W {
1456 self.bit(false)
1457 }
1458 #[doc = r"Writes raw bits to the field"]
1459 #[inline(always)]
1460 pub fn bit(self, value: bool) -> &'a mut W {
1461 self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
1462 self.w
1463 }
1464}
1465#[doc = "Secure mask for pin P0_17\n\nValue on reset: 1"]
1466#[derive(Clone, Copy, Debug, PartialEq)]
1467pub enum PIO0_PIN17_SEC_MASK_A {
1468 #[doc = "0: Pin state is blocked to non-secure world."]
1469 BLOCKED = 0,
1470 #[doc = "1: Pin state is readable by non-secure world."]
1471 READABLE = 1,
1472}
1473impl From<PIO0_PIN17_SEC_MASK_A> for bool {
1474 #[inline(always)]
1475 fn from(variant: PIO0_PIN17_SEC_MASK_A) -> Self {
1476 variant as u8 != 0
1477 }
1478}
1479#[doc = "Field `PIO0_PIN17_SEC_MASK` reader - Secure mask for pin P0_17"]
1480pub struct PIO0_PIN17_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN17_SEC_MASK_A>);
1481impl PIO0_PIN17_SEC_MASK_R {
1482 #[inline(always)]
1483 pub(crate) fn new(bits: bool) -> Self {
1484 PIO0_PIN17_SEC_MASK_R(crate::FieldReader::new(bits))
1485 }
1486 #[doc = r"Get enumerated values variant"]
1487 #[inline(always)]
1488 pub fn variant(&self) -> PIO0_PIN17_SEC_MASK_A {
1489 match self.bits {
1490 false => PIO0_PIN17_SEC_MASK_A::BLOCKED,
1491 true => PIO0_PIN17_SEC_MASK_A::READABLE,
1492 }
1493 }
1494 #[doc = "Checks if the value of the field is `BLOCKED`"]
1495 #[inline(always)]
1496 pub fn is_blocked(&self) -> bool {
1497 **self == PIO0_PIN17_SEC_MASK_A::BLOCKED
1498 }
1499 #[doc = "Checks if the value of the field is `READABLE`"]
1500 #[inline(always)]
1501 pub fn is_readable(&self) -> bool {
1502 **self == PIO0_PIN17_SEC_MASK_A::READABLE
1503 }
1504}
1505impl core::ops::Deref for PIO0_PIN17_SEC_MASK_R {
1506 type Target = crate::FieldReader<bool, PIO0_PIN17_SEC_MASK_A>;
1507 #[inline(always)]
1508 fn deref(&self) -> &Self::Target {
1509 &self.0
1510 }
1511}
1512#[doc = "Field `PIO0_PIN17_SEC_MASK` writer - Secure mask for pin P0_17"]
1513pub struct PIO0_PIN17_SEC_MASK_W<'a> {
1514 w: &'a mut W,
1515}
1516impl<'a> PIO0_PIN17_SEC_MASK_W<'a> {
1517 #[doc = r"Writes `variant` to the field"]
1518 #[inline(always)]
1519 pub fn variant(self, variant: PIO0_PIN17_SEC_MASK_A) -> &'a mut W {
1520 self.bit(variant.into())
1521 }
1522 #[doc = "Pin state is blocked to non-secure world."]
1523 #[inline(always)]
1524 pub fn blocked(self) -> &'a mut W {
1525 self.variant(PIO0_PIN17_SEC_MASK_A::BLOCKED)
1526 }
1527 #[doc = "Pin state is readable by non-secure world."]
1528 #[inline(always)]
1529 pub fn readable(self) -> &'a mut W {
1530 self.variant(PIO0_PIN17_SEC_MASK_A::READABLE)
1531 }
1532 #[doc = r"Sets the field bit"]
1533 #[inline(always)]
1534 pub fn set_bit(self) -> &'a mut W {
1535 self.bit(true)
1536 }
1537 #[doc = r"Clears the field bit"]
1538 #[inline(always)]
1539 pub fn clear_bit(self) -> &'a mut W {
1540 self.bit(false)
1541 }
1542 #[doc = r"Writes raw bits to the field"]
1543 #[inline(always)]
1544 pub fn bit(self, value: bool) -> &'a mut W {
1545 self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
1546 self.w
1547 }
1548}
1549#[doc = "Secure mask for pin P0_18\n\nValue on reset: 1"]
1550#[derive(Clone, Copy, Debug, PartialEq)]
1551pub enum PIO0_PIN18_SEC_MASK_A {
1552 #[doc = "0: Pin state is blocked to non-secure world."]
1553 BLOCKED = 0,
1554 #[doc = "1: Pin state is readable by non-secure world."]
1555 READABLE = 1,
1556}
1557impl From<PIO0_PIN18_SEC_MASK_A> for bool {
1558 #[inline(always)]
1559 fn from(variant: PIO0_PIN18_SEC_MASK_A) -> Self {
1560 variant as u8 != 0
1561 }
1562}
1563#[doc = "Field `PIO0_PIN18_SEC_MASK` reader - Secure mask for pin P0_18"]
1564pub struct PIO0_PIN18_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN18_SEC_MASK_A>);
1565impl PIO0_PIN18_SEC_MASK_R {
1566 #[inline(always)]
1567 pub(crate) fn new(bits: bool) -> Self {
1568 PIO0_PIN18_SEC_MASK_R(crate::FieldReader::new(bits))
1569 }
1570 #[doc = r"Get enumerated values variant"]
1571 #[inline(always)]
1572 pub fn variant(&self) -> PIO0_PIN18_SEC_MASK_A {
1573 match self.bits {
1574 false => PIO0_PIN18_SEC_MASK_A::BLOCKED,
1575 true => PIO0_PIN18_SEC_MASK_A::READABLE,
1576 }
1577 }
1578 #[doc = "Checks if the value of the field is `BLOCKED`"]
1579 #[inline(always)]
1580 pub fn is_blocked(&self) -> bool {
1581 **self == PIO0_PIN18_SEC_MASK_A::BLOCKED
1582 }
1583 #[doc = "Checks if the value of the field is `READABLE`"]
1584 #[inline(always)]
1585 pub fn is_readable(&self) -> bool {
1586 **self == PIO0_PIN18_SEC_MASK_A::READABLE
1587 }
1588}
1589impl core::ops::Deref for PIO0_PIN18_SEC_MASK_R {
1590 type Target = crate::FieldReader<bool, PIO0_PIN18_SEC_MASK_A>;
1591 #[inline(always)]
1592 fn deref(&self) -> &Self::Target {
1593 &self.0
1594 }
1595}
1596#[doc = "Field `PIO0_PIN18_SEC_MASK` writer - Secure mask for pin P0_18"]
1597pub struct PIO0_PIN18_SEC_MASK_W<'a> {
1598 w: &'a mut W,
1599}
1600impl<'a> PIO0_PIN18_SEC_MASK_W<'a> {
1601 #[doc = r"Writes `variant` to the field"]
1602 #[inline(always)]
1603 pub fn variant(self, variant: PIO0_PIN18_SEC_MASK_A) -> &'a mut W {
1604 self.bit(variant.into())
1605 }
1606 #[doc = "Pin state is blocked to non-secure world."]
1607 #[inline(always)]
1608 pub fn blocked(self) -> &'a mut W {
1609 self.variant(PIO0_PIN18_SEC_MASK_A::BLOCKED)
1610 }
1611 #[doc = "Pin state is readable by non-secure world."]
1612 #[inline(always)]
1613 pub fn readable(self) -> &'a mut W {
1614 self.variant(PIO0_PIN18_SEC_MASK_A::READABLE)
1615 }
1616 #[doc = r"Sets the field bit"]
1617 #[inline(always)]
1618 pub fn set_bit(self) -> &'a mut W {
1619 self.bit(true)
1620 }
1621 #[doc = r"Clears the field bit"]
1622 #[inline(always)]
1623 pub fn clear_bit(self) -> &'a mut W {
1624 self.bit(false)
1625 }
1626 #[doc = r"Writes raw bits to the field"]
1627 #[inline(always)]
1628 pub fn bit(self, value: bool) -> &'a mut W {
1629 self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
1630 self.w
1631 }
1632}
1633#[doc = "Secure mask for pin P0_19\n\nValue on reset: 1"]
1634#[derive(Clone, Copy, Debug, PartialEq)]
1635pub enum PIO0_PIN19_SEC_MASK_A {
1636 #[doc = "0: Pin state is blocked to non-secure world."]
1637 BLOCKED = 0,
1638 #[doc = "1: Pin state is readable by non-secure world."]
1639 READABLE = 1,
1640}
1641impl From<PIO0_PIN19_SEC_MASK_A> for bool {
1642 #[inline(always)]
1643 fn from(variant: PIO0_PIN19_SEC_MASK_A) -> Self {
1644 variant as u8 != 0
1645 }
1646}
1647#[doc = "Field `PIO0_PIN19_SEC_MASK` reader - Secure mask for pin P0_19"]
1648pub struct PIO0_PIN19_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN19_SEC_MASK_A>);
1649impl PIO0_PIN19_SEC_MASK_R {
1650 #[inline(always)]
1651 pub(crate) fn new(bits: bool) -> Self {
1652 PIO0_PIN19_SEC_MASK_R(crate::FieldReader::new(bits))
1653 }
1654 #[doc = r"Get enumerated values variant"]
1655 #[inline(always)]
1656 pub fn variant(&self) -> PIO0_PIN19_SEC_MASK_A {
1657 match self.bits {
1658 false => PIO0_PIN19_SEC_MASK_A::BLOCKED,
1659 true => PIO0_PIN19_SEC_MASK_A::READABLE,
1660 }
1661 }
1662 #[doc = "Checks if the value of the field is `BLOCKED`"]
1663 #[inline(always)]
1664 pub fn is_blocked(&self) -> bool {
1665 **self == PIO0_PIN19_SEC_MASK_A::BLOCKED
1666 }
1667 #[doc = "Checks if the value of the field is `READABLE`"]
1668 #[inline(always)]
1669 pub fn is_readable(&self) -> bool {
1670 **self == PIO0_PIN19_SEC_MASK_A::READABLE
1671 }
1672}
1673impl core::ops::Deref for PIO0_PIN19_SEC_MASK_R {
1674 type Target = crate::FieldReader<bool, PIO0_PIN19_SEC_MASK_A>;
1675 #[inline(always)]
1676 fn deref(&self) -> &Self::Target {
1677 &self.0
1678 }
1679}
1680#[doc = "Field `PIO0_PIN19_SEC_MASK` writer - Secure mask for pin P0_19"]
1681pub struct PIO0_PIN19_SEC_MASK_W<'a> {
1682 w: &'a mut W,
1683}
1684impl<'a> PIO0_PIN19_SEC_MASK_W<'a> {
1685 #[doc = r"Writes `variant` to the field"]
1686 #[inline(always)]
1687 pub fn variant(self, variant: PIO0_PIN19_SEC_MASK_A) -> &'a mut W {
1688 self.bit(variant.into())
1689 }
1690 #[doc = "Pin state is blocked to non-secure world."]
1691 #[inline(always)]
1692 pub fn blocked(self) -> &'a mut W {
1693 self.variant(PIO0_PIN19_SEC_MASK_A::BLOCKED)
1694 }
1695 #[doc = "Pin state is readable by non-secure world."]
1696 #[inline(always)]
1697 pub fn readable(self) -> &'a mut W {
1698 self.variant(PIO0_PIN19_SEC_MASK_A::READABLE)
1699 }
1700 #[doc = r"Sets the field bit"]
1701 #[inline(always)]
1702 pub fn set_bit(self) -> &'a mut W {
1703 self.bit(true)
1704 }
1705 #[doc = r"Clears the field bit"]
1706 #[inline(always)]
1707 pub fn clear_bit(self) -> &'a mut W {
1708 self.bit(false)
1709 }
1710 #[doc = r"Writes raw bits to the field"]
1711 #[inline(always)]
1712 pub fn bit(self, value: bool) -> &'a mut W {
1713 self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
1714 self.w
1715 }
1716}
1717#[doc = "Secure mask for pin P0_20\n\nValue on reset: 1"]
1718#[derive(Clone, Copy, Debug, PartialEq)]
1719pub enum PIO0_PIN20_SEC_MASK_A {
1720 #[doc = "0: Pin state is blocked to non-secure world."]
1721 BLOCKED = 0,
1722 #[doc = "1: Pin state is readable by non-secure world."]
1723 READABLE = 1,
1724}
1725impl From<PIO0_PIN20_SEC_MASK_A> for bool {
1726 #[inline(always)]
1727 fn from(variant: PIO0_PIN20_SEC_MASK_A) -> Self {
1728 variant as u8 != 0
1729 }
1730}
1731#[doc = "Field `PIO0_PIN20_SEC_MASK` reader - Secure mask for pin P0_20"]
1732pub struct PIO0_PIN20_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN20_SEC_MASK_A>);
1733impl PIO0_PIN20_SEC_MASK_R {
1734 #[inline(always)]
1735 pub(crate) fn new(bits: bool) -> Self {
1736 PIO0_PIN20_SEC_MASK_R(crate::FieldReader::new(bits))
1737 }
1738 #[doc = r"Get enumerated values variant"]
1739 #[inline(always)]
1740 pub fn variant(&self) -> PIO0_PIN20_SEC_MASK_A {
1741 match self.bits {
1742 false => PIO0_PIN20_SEC_MASK_A::BLOCKED,
1743 true => PIO0_PIN20_SEC_MASK_A::READABLE,
1744 }
1745 }
1746 #[doc = "Checks if the value of the field is `BLOCKED`"]
1747 #[inline(always)]
1748 pub fn is_blocked(&self) -> bool {
1749 **self == PIO0_PIN20_SEC_MASK_A::BLOCKED
1750 }
1751 #[doc = "Checks if the value of the field is `READABLE`"]
1752 #[inline(always)]
1753 pub fn is_readable(&self) -> bool {
1754 **self == PIO0_PIN20_SEC_MASK_A::READABLE
1755 }
1756}
1757impl core::ops::Deref for PIO0_PIN20_SEC_MASK_R {
1758 type Target = crate::FieldReader<bool, PIO0_PIN20_SEC_MASK_A>;
1759 #[inline(always)]
1760 fn deref(&self) -> &Self::Target {
1761 &self.0
1762 }
1763}
1764#[doc = "Field `PIO0_PIN20_SEC_MASK` writer - Secure mask for pin P0_20"]
1765pub struct PIO0_PIN20_SEC_MASK_W<'a> {
1766 w: &'a mut W,
1767}
1768impl<'a> PIO0_PIN20_SEC_MASK_W<'a> {
1769 #[doc = r"Writes `variant` to the field"]
1770 #[inline(always)]
1771 pub fn variant(self, variant: PIO0_PIN20_SEC_MASK_A) -> &'a mut W {
1772 self.bit(variant.into())
1773 }
1774 #[doc = "Pin state is blocked to non-secure world."]
1775 #[inline(always)]
1776 pub fn blocked(self) -> &'a mut W {
1777 self.variant(PIO0_PIN20_SEC_MASK_A::BLOCKED)
1778 }
1779 #[doc = "Pin state is readable by non-secure world."]
1780 #[inline(always)]
1781 pub fn readable(self) -> &'a mut W {
1782 self.variant(PIO0_PIN20_SEC_MASK_A::READABLE)
1783 }
1784 #[doc = r"Sets the field bit"]
1785 #[inline(always)]
1786 pub fn set_bit(self) -> &'a mut W {
1787 self.bit(true)
1788 }
1789 #[doc = r"Clears the field bit"]
1790 #[inline(always)]
1791 pub fn clear_bit(self) -> &'a mut W {
1792 self.bit(false)
1793 }
1794 #[doc = r"Writes raw bits to the field"]
1795 #[inline(always)]
1796 pub fn bit(self, value: bool) -> &'a mut W {
1797 self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
1798 self.w
1799 }
1800}
1801#[doc = "Secure mask for pin P0_21\n\nValue on reset: 1"]
1802#[derive(Clone, Copy, Debug, PartialEq)]
1803pub enum PIO0_PIN21_SEC_MASK_A {
1804 #[doc = "0: Pin state is blocked to non-secure world."]
1805 BLOCKED = 0,
1806 #[doc = "1: Pin state is readable by non-secure world."]
1807 READABLE = 1,
1808}
1809impl From<PIO0_PIN21_SEC_MASK_A> for bool {
1810 #[inline(always)]
1811 fn from(variant: PIO0_PIN21_SEC_MASK_A) -> Self {
1812 variant as u8 != 0
1813 }
1814}
1815#[doc = "Field `PIO0_PIN21_SEC_MASK` reader - Secure mask for pin P0_21"]
1816pub struct PIO0_PIN21_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN21_SEC_MASK_A>);
1817impl PIO0_PIN21_SEC_MASK_R {
1818 #[inline(always)]
1819 pub(crate) fn new(bits: bool) -> Self {
1820 PIO0_PIN21_SEC_MASK_R(crate::FieldReader::new(bits))
1821 }
1822 #[doc = r"Get enumerated values variant"]
1823 #[inline(always)]
1824 pub fn variant(&self) -> PIO0_PIN21_SEC_MASK_A {
1825 match self.bits {
1826 false => PIO0_PIN21_SEC_MASK_A::BLOCKED,
1827 true => PIO0_PIN21_SEC_MASK_A::READABLE,
1828 }
1829 }
1830 #[doc = "Checks if the value of the field is `BLOCKED`"]
1831 #[inline(always)]
1832 pub fn is_blocked(&self) -> bool {
1833 **self == PIO0_PIN21_SEC_MASK_A::BLOCKED
1834 }
1835 #[doc = "Checks if the value of the field is `READABLE`"]
1836 #[inline(always)]
1837 pub fn is_readable(&self) -> bool {
1838 **self == PIO0_PIN21_SEC_MASK_A::READABLE
1839 }
1840}
1841impl core::ops::Deref for PIO0_PIN21_SEC_MASK_R {
1842 type Target = crate::FieldReader<bool, PIO0_PIN21_SEC_MASK_A>;
1843 #[inline(always)]
1844 fn deref(&self) -> &Self::Target {
1845 &self.0
1846 }
1847}
1848#[doc = "Field `PIO0_PIN21_SEC_MASK` writer - Secure mask for pin P0_21"]
1849pub struct PIO0_PIN21_SEC_MASK_W<'a> {
1850 w: &'a mut W,
1851}
1852impl<'a> PIO0_PIN21_SEC_MASK_W<'a> {
1853 #[doc = r"Writes `variant` to the field"]
1854 #[inline(always)]
1855 pub fn variant(self, variant: PIO0_PIN21_SEC_MASK_A) -> &'a mut W {
1856 self.bit(variant.into())
1857 }
1858 #[doc = "Pin state is blocked to non-secure world."]
1859 #[inline(always)]
1860 pub fn blocked(self) -> &'a mut W {
1861 self.variant(PIO0_PIN21_SEC_MASK_A::BLOCKED)
1862 }
1863 #[doc = "Pin state is readable by non-secure world."]
1864 #[inline(always)]
1865 pub fn readable(self) -> &'a mut W {
1866 self.variant(PIO0_PIN21_SEC_MASK_A::READABLE)
1867 }
1868 #[doc = r"Sets the field bit"]
1869 #[inline(always)]
1870 pub fn set_bit(self) -> &'a mut W {
1871 self.bit(true)
1872 }
1873 #[doc = r"Clears the field bit"]
1874 #[inline(always)]
1875 pub fn clear_bit(self) -> &'a mut W {
1876 self.bit(false)
1877 }
1878 #[doc = r"Writes raw bits to the field"]
1879 #[inline(always)]
1880 pub fn bit(self, value: bool) -> &'a mut W {
1881 self.w.bits = (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
1882 self.w
1883 }
1884}
1885#[doc = "Secure mask for pin P0_22\n\nValue on reset: 1"]
1886#[derive(Clone, Copy, Debug, PartialEq)]
1887pub enum PIO0_PIN22_SEC_MASK_A {
1888 #[doc = "0: Pin state is blocked to non-secure world."]
1889 BLOCKED = 0,
1890 #[doc = "1: Pin state is readable by non-secure world."]
1891 READABLE = 1,
1892}
1893impl From<PIO0_PIN22_SEC_MASK_A> for bool {
1894 #[inline(always)]
1895 fn from(variant: PIO0_PIN22_SEC_MASK_A) -> Self {
1896 variant as u8 != 0
1897 }
1898}
1899#[doc = "Field `PIO0_PIN22_SEC_MASK` reader - Secure mask for pin P0_22"]
1900pub struct PIO0_PIN22_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN22_SEC_MASK_A>);
1901impl PIO0_PIN22_SEC_MASK_R {
1902 #[inline(always)]
1903 pub(crate) fn new(bits: bool) -> Self {
1904 PIO0_PIN22_SEC_MASK_R(crate::FieldReader::new(bits))
1905 }
1906 #[doc = r"Get enumerated values variant"]
1907 #[inline(always)]
1908 pub fn variant(&self) -> PIO0_PIN22_SEC_MASK_A {
1909 match self.bits {
1910 false => PIO0_PIN22_SEC_MASK_A::BLOCKED,
1911 true => PIO0_PIN22_SEC_MASK_A::READABLE,
1912 }
1913 }
1914 #[doc = "Checks if the value of the field is `BLOCKED`"]
1915 #[inline(always)]
1916 pub fn is_blocked(&self) -> bool {
1917 **self == PIO0_PIN22_SEC_MASK_A::BLOCKED
1918 }
1919 #[doc = "Checks if the value of the field is `READABLE`"]
1920 #[inline(always)]
1921 pub fn is_readable(&self) -> bool {
1922 **self == PIO0_PIN22_SEC_MASK_A::READABLE
1923 }
1924}
1925impl core::ops::Deref for PIO0_PIN22_SEC_MASK_R {
1926 type Target = crate::FieldReader<bool, PIO0_PIN22_SEC_MASK_A>;
1927 #[inline(always)]
1928 fn deref(&self) -> &Self::Target {
1929 &self.0
1930 }
1931}
1932#[doc = "Field `PIO0_PIN22_SEC_MASK` writer - Secure mask for pin P0_22"]
1933pub struct PIO0_PIN22_SEC_MASK_W<'a> {
1934 w: &'a mut W,
1935}
1936impl<'a> PIO0_PIN22_SEC_MASK_W<'a> {
1937 #[doc = r"Writes `variant` to the field"]
1938 #[inline(always)]
1939 pub fn variant(self, variant: PIO0_PIN22_SEC_MASK_A) -> &'a mut W {
1940 self.bit(variant.into())
1941 }
1942 #[doc = "Pin state is blocked to non-secure world."]
1943 #[inline(always)]
1944 pub fn blocked(self) -> &'a mut W {
1945 self.variant(PIO0_PIN22_SEC_MASK_A::BLOCKED)
1946 }
1947 #[doc = "Pin state is readable by non-secure world."]
1948 #[inline(always)]
1949 pub fn readable(self) -> &'a mut W {
1950 self.variant(PIO0_PIN22_SEC_MASK_A::READABLE)
1951 }
1952 #[doc = r"Sets the field bit"]
1953 #[inline(always)]
1954 pub fn set_bit(self) -> &'a mut W {
1955 self.bit(true)
1956 }
1957 #[doc = r"Clears the field bit"]
1958 #[inline(always)]
1959 pub fn clear_bit(self) -> &'a mut W {
1960 self.bit(false)
1961 }
1962 #[doc = r"Writes raw bits to the field"]
1963 #[inline(always)]
1964 pub fn bit(self, value: bool) -> &'a mut W {
1965 self.w.bits = (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
1966 self.w
1967 }
1968}
1969#[doc = "Secure mask for pin P0_23\n\nValue on reset: 1"]
1970#[derive(Clone, Copy, Debug, PartialEq)]
1971pub enum PIO0_PIN23_SEC_MASK_A {
1972 #[doc = "0: Pin state is blocked to non-secure world."]
1973 BLOCKED = 0,
1974 #[doc = "1: Pin state is readable by non-secure world."]
1975 READABLE = 1,
1976}
1977impl From<PIO0_PIN23_SEC_MASK_A> for bool {
1978 #[inline(always)]
1979 fn from(variant: PIO0_PIN23_SEC_MASK_A) -> Self {
1980 variant as u8 != 0
1981 }
1982}
1983#[doc = "Field `PIO0_PIN23_SEC_MASK` reader - Secure mask for pin P0_23"]
1984pub struct PIO0_PIN23_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN23_SEC_MASK_A>);
1985impl PIO0_PIN23_SEC_MASK_R {
1986 #[inline(always)]
1987 pub(crate) fn new(bits: bool) -> Self {
1988 PIO0_PIN23_SEC_MASK_R(crate::FieldReader::new(bits))
1989 }
1990 #[doc = r"Get enumerated values variant"]
1991 #[inline(always)]
1992 pub fn variant(&self) -> PIO0_PIN23_SEC_MASK_A {
1993 match self.bits {
1994 false => PIO0_PIN23_SEC_MASK_A::BLOCKED,
1995 true => PIO0_PIN23_SEC_MASK_A::READABLE,
1996 }
1997 }
1998 #[doc = "Checks if the value of the field is `BLOCKED`"]
1999 #[inline(always)]
2000 pub fn is_blocked(&self) -> bool {
2001 **self == PIO0_PIN23_SEC_MASK_A::BLOCKED
2002 }
2003 #[doc = "Checks if the value of the field is `READABLE`"]
2004 #[inline(always)]
2005 pub fn is_readable(&self) -> bool {
2006 **self == PIO0_PIN23_SEC_MASK_A::READABLE
2007 }
2008}
2009impl core::ops::Deref for PIO0_PIN23_SEC_MASK_R {
2010 type Target = crate::FieldReader<bool, PIO0_PIN23_SEC_MASK_A>;
2011 #[inline(always)]
2012 fn deref(&self) -> &Self::Target {
2013 &self.0
2014 }
2015}
2016#[doc = "Field `PIO0_PIN23_SEC_MASK` writer - Secure mask for pin P0_23"]
2017pub struct PIO0_PIN23_SEC_MASK_W<'a> {
2018 w: &'a mut W,
2019}
2020impl<'a> PIO0_PIN23_SEC_MASK_W<'a> {
2021 #[doc = r"Writes `variant` to the field"]
2022 #[inline(always)]
2023 pub fn variant(self, variant: PIO0_PIN23_SEC_MASK_A) -> &'a mut W {
2024 self.bit(variant.into())
2025 }
2026 #[doc = "Pin state is blocked to non-secure world."]
2027 #[inline(always)]
2028 pub fn blocked(self) -> &'a mut W {
2029 self.variant(PIO0_PIN23_SEC_MASK_A::BLOCKED)
2030 }
2031 #[doc = "Pin state is readable by non-secure world."]
2032 #[inline(always)]
2033 pub fn readable(self) -> &'a mut W {
2034 self.variant(PIO0_PIN23_SEC_MASK_A::READABLE)
2035 }
2036 #[doc = r"Sets the field bit"]
2037 #[inline(always)]
2038 pub fn set_bit(self) -> &'a mut W {
2039 self.bit(true)
2040 }
2041 #[doc = r"Clears the field bit"]
2042 #[inline(always)]
2043 pub fn clear_bit(self) -> &'a mut W {
2044 self.bit(false)
2045 }
2046 #[doc = r"Writes raw bits to the field"]
2047 #[inline(always)]
2048 pub fn bit(self, value: bool) -> &'a mut W {
2049 self.w.bits = (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
2050 self.w
2051 }
2052}
2053#[doc = "Secure mask for pin P0_24\n\nValue on reset: 1"]
2054#[derive(Clone, Copy, Debug, PartialEq)]
2055pub enum PIO0_PIN24_SEC_MASK_A {
2056 #[doc = "0: Pin state is blocked to non-secure world."]
2057 BLOCKED = 0,
2058 #[doc = "1: Pin state is readable by non-secure world."]
2059 READABLE = 1,
2060}
2061impl From<PIO0_PIN24_SEC_MASK_A> for bool {
2062 #[inline(always)]
2063 fn from(variant: PIO0_PIN24_SEC_MASK_A) -> Self {
2064 variant as u8 != 0
2065 }
2066}
2067#[doc = "Field `PIO0_PIN24_SEC_MASK` reader - Secure mask for pin P0_24"]
2068pub struct PIO0_PIN24_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN24_SEC_MASK_A>);
2069impl PIO0_PIN24_SEC_MASK_R {
2070 #[inline(always)]
2071 pub(crate) fn new(bits: bool) -> Self {
2072 PIO0_PIN24_SEC_MASK_R(crate::FieldReader::new(bits))
2073 }
2074 #[doc = r"Get enumerated values variant"]
2075 #[inline(always)]
2076 pub fn variant(&self) -> PIO0_PIN24_SEC_MASK_A {
2077 match self.bits {
2078 false => PIO0_PIN24_SEC_MASK_A::BLOCKED,
2079 true => PIO0_PIN24_SEC_MASK_A::READABLE,
2080 }
2081 }
2082 #[doc = "Checks if the value of the field is `BLOCKED`"]
2083 #[inline(always)]
2084 pub fn is_blocked(&self) -> bool {
2085 **self == PIO0_PIN24_SEC_MASK_A::BLOCKED
2086 }
2087 #[doc = "Checks if the value of the field is `READABLE`"]
2088 #[inline(always)]
2089 pub fn is_readable(&self) -> bool {
2090 **self == PIO0_PIN24_SEC_MASK_A::READABLE
2091 }
2092}
2093impl core::ops::Deref for PIO0_PIN24_SEC_MASK_R {
2094 type Target = crate::FieldReader<bool, PIO0_PIN24_SEC_MASK_A>;
2095 #[inline(always)]
2096 fn deref(&self) -> &Self::Target {
2097 &self.0
2098 }
2099}
2100#[doc = "Field `PIO0_PIN24_SEC_MASK` writer - Secure mask for pin P0_24"]
2101pub struct PIO0_PIN24_SEC_MASK_W<'a> {
2102 w: &'a mut W,
2103}
2104impl<'a> PIO0_PIN24_SEC_MASK_W<'a> {
2105 #[doc = r"Writes `variant` to the field"]
2106 #[inline(always)]
2107 pub fn variant(self, variant: PIO0_PIN24_SEC_MASK_A) -> &'a mut W {
2108 self.bit(variant.into())
2109 }
2110 #[doc = "Pin state is blocked to non-secure world."]
2111 #[inline(always)]
2112 pub fn blocked(self) -> &'a mut W {
2113 self.variant(PIO0_PIN24_SEC_MASK_A::BLOCKED)
2114 }
2115 #[doc = "Pin state is readable by non-secure world."]
2116 #[inline(always)]
2117 pub fn readable(self) -> &'a mut W {
2118 self.variant(PIO0_PIN24_SEC_MASK_A::READABLE)
2119 }
2120 #[doc = r"Sets the field bit"]
2121 #[inline(always)]
2122 pub fn set_bit(self) -> &'a mut W {
2123 self.bit(true)
2124 }
2125 #[doc = r"Clears the field bit"]
2126 #[inline(always)]
2127 pub fn clear_bit(self) -> &'a mut W {
2128 self.bit(false)
2129 }
2130 #[doc = r"Writes raw bits to the field"]
2131 #[inline(always)]
2132 pub fn bit(self, value: bool) -> &'a mut W {
2133 self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
2134 self.w
2135 }
2136}
2137#[doc = "Secure mask for pin P0_25\n\nValue on reset: 1"]
2138#[derive(Clone, Copy, Debug, PartialEq)]
2139pub enum PIO0_PIN25_SEC_MASK_A {
2140 #[doc = "0: Pin state is blocked to non-secure world."]
2141 BLOCKED = 0,
2142 #[doc = "1: Pin state is readable by non-secure world."]
2143 READABLE = 1,
2144}
2145impl From<PIO0_PIN25_SEC_MASK_A> for bool {
2146 #[inline(always)]
2147 fn from(variant: PIO0_PIN25_SEC_MASK_A) -> Self {
2148 variant as u8 != 0
2149 }
2150}
2151#[doc = "Field `PIO0_PIN25_SEC_MASK` reader - Secure mask for pin P0_25"]
2152pub struct PIO0_PIN25_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN25_SEC_MASK_A>);
2153impl PIO0_PIN25_SEC_MASK_R {
2154 #[inline(always)]
2155 pub(crate) fn new(bits: bool) -> Self {
2156 PIO0_PIN25_SEC_MASK_R(crate::FieldReader::new(bits))
2157 }
2158 #[doc = r"Get enumerated values variant"]
2159 #[inline(always)]
2160 pub fn variant(&self) -> PIO0_PIN25_SEC_MASK_A {
2161 match self.bits {
2162 false => PIO0_PIN25_SEC_MASK_A::BLOCKED,
2163 true => PIO0_PIN25_SEC_MASK_A::READABLE,
2164 }
2165 }
2166 #[doc = "Checks if the value of the field is `BLOCKED`"]
2167 #[inline(always)]
2168 pub fn is_blocked(&self) -> bool {
2169 **self == PIO0_PIN25_SEC_MASK_A::BLOCKED
2170 }
2171 #[doc = "Checks if the value of the field is `READABLE`"]
2172 #[inline(always)]
2173 pub fn is_readable(&self) -> bool {
2174 **self == PIO0_PIN25_SEC_MASK_A::READABLE
2175 }
2176}
2177impl core::ops::Deref for PIO0_PIN25_SEC_MASK_R {
2178 type Target = crate::FieldReader<bool, PIO0_PIN25_SEC_MASK_A>;
2179 #[inline(always)]
2180 fn deref(&self) -> &Self::Target {
2181 &self.0
2182 }
2183}
2184#[doc = "Field `PIO0_PIN25_SEC_MASK` writer - Secure mask for pin P0_25"]
2185pub struct PIO0_PIN25_SEC_MASK_W<'a> {
2186 w: &'a mut W,
2187}
2188impl<'a> PIO0_PIN25_SEC_MASK_W<'a> {
2189 #[doc = r"Writes `variant` to the field"]
2190 #[inline(always)]
2191 pub fn variant(self, variant: PIO0_PIN25_SEC_MASK_A) -> &'a mut W {
2192 self.bit(variant.into())
2193 }
2194 #[doc = "Pin state is blocked to non-secure world."]
2195 #[inline(always)]
2196 pub fn blocked(self) -> &'a mut W {
2197 self.variant(PIO0_PIN25_SEC_MASK_A::BLOCKED)
2198 }
2199 #[doc = "Pin state is readable by non-secure world."]
2200 #[inline(always)]
2201 pub fn readable(self) -> &'a mut W {
2202 self.variant(PIO0_PIN25_SEC_MASK_A::READABLE)
2203 }
2204 #[doc = r"Sets the field bit"]
2205 #[inline(always)]
2206 pub fn set_bit(self) -> &'a mut W {
2207 self.bit(true)
2208 }
2209 #[doc = r"Clears the field bit"]
2210 #[inline(always)]
2211 pub fn clear_bit(self) -> &'a mut W {
2212 self.bit(false)
2213 }
2214 #[doc = r"Writes raw bits to the field"]
2215 #[inline(always)]
2216 pub fn bit(self, value: bool) -> &'a mut W {
2217 self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
2218 self.w
2219 }
2220}
2221#[doc = "Secure mask for pin P0_26\n\nValue on reset: 1"]
2222#[derive(Clone, Copy, Debug, PartialEq)]
2223pub enum PIO0_PIN26_SEC_MASK_A {
2224 #[doc = "0: Pin state is blocked to non-secure world."]
2225 BLOCKED = 0,
2226 #[doc = "1: Pin state is readable by non-secure world."]
2227 READABLE = 1,
2228}
2229impl From<PIO0_PIN26_SEC_MASK_A> for bool {
2230 #[inline(always)]
2231 fn from(variant: PIO0_PIN26_SEC_MASK_A) -> Self {
2232 variant as u8 != 0
2233 }
2234}
2235#[doc = "Field `PIO0_PIN26_SEC_MASK` reader - Secure mask for pin P0_26"]
2236pub struct PIO0_PIN26_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN26_SEC_MASK_A>);
2237impl PIO0_PIN26_SEC_MASK_R {
2238 #[inline(always)]
2239 pub(crate) fn new(bits: bool) -> Self {
2240 PIO0_PIN26_SEC_MASK_R(crate::FieldReader::new(bits))
2241 }
2242 #[doc = r"Get enumerated values variant"]
2243 #[inline(always)]
2244 pub fn variant(&self) -> PIO0_PIN26_SEC_MASK_A {
2245 match self.bits {
2246 false => PIO0_PIN26_SEC_MASK_A::BLOCKED,
2247 true => PIO0_PIN26_SEC_MASK_A::READABLE,
2248 }
2249 }
2250 #[doc = "Checks if the value of the field is `BLOCKED`"]
2251 #[inline(always)]
2252 pub fn is_blocked(&self) -> bool {
2253 **self == PIO0_PIN26_SEC_MASK_A::BLOCKED
2254 }
2255 #[doc = "Checks if the value of the field is `READABLE`"]
2256 #[inline(always)]
2257 pub fn is_readable(&self) -> bool {
2258 **self == PIO0_PIN26_SEC_MASK_A::READABLE
2259 }
2260}
2261impl core::ops::Deref for PIO0_PIN26_SEC_MASK_R {
2262 type Target = crate::FieldReader<bool, PIO0_PIN26_SEC_MASK_A>;
2263 #[inline(always)]
2264 fn deref(&self) -> &Self::Target {
2265 &self.0
2266 }
2267}
2268#[doc = "Field `PIO0_PIN26_SEC_MASK` writer - Secure mask for pin P0_26"]
2269pub struct PIO0_PIN26_SEC_MASK_W<'a> {
2270 w: &'a mut W,
2271}
2272impl<'a> PIO0_PIN26_SEC_MASK_W<'a> {
2273 #[doc = r"Writes `variant` to the field"]
2274 #[inline(always)]
2275 pub fn variant(self, variant: PIO0_PIN26_SEC_MASK_A) -> &'a mut W {
2276 self.bit(variant.into())
2277 }
2278 #[doc = "Pin state is blocked to non-secure world."]
2279 #[inline(always)]
2280 pub fn blocked(self) -> &'a mut W {
2281 self.variant(PIO0_PIN26_SEC_MASK_A::BLOCKED)
2282 }
2283 #[doc = "Pin state is readable by non-secure world."]
2284 #[inline(always)]
2285 pub fn readable(self) -> &'a mut W {
2286 self.variant(PIO0_PIN26_SEC_MASK_A::READABLE)
2287 }
2288 #[doc = r"Sets the field bit"]
2289 #[inline(always)]
2290 pub fn set_bit(self) -> &'a mut W {
2291 self.bit(true)
2292 }
2293 #[doc = r"Clears the field bit"]
2294 #[inline(always)]
2295 pub fn clear_bit(self) -> &'a mut W {
2296 self.bit(false)
2297 }
2298 #[doc = r"Writes raw bits to the field"]
2299 #[inline(always)]
2300 pub fn bit(self, value: bool) -> &'a mut W {
2301 self.w.bits = (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
2302 self.w
2303 }
2304}
2305#[doc = "Secure mask for pin P0_27\n\nValue on reset: 1"]
2306#[derive(Clone, Copy, Debug, PartialEq)]
2307pub enum PIO0_PIN27_SEC_MASK_A {
2308 #[doc = "0: Pin state is blocked to non-secure world."]
2309 BLOCKED = 0,
2310 #[doc = "1: Pin state is readable by non-secure world."]
2311 READABLE = 1,
2312}
2313impl From<PIO0_PIN27_SEC_MASK_A> for bool {
2314 #[inline(always)]
2315 fn from(variant: PIO0_PIN27_SEC_MASK_A) -> Self {
2316 variant as u8 != 0
2317 }
2318}
2319#[doc = "Field `PIO0_PIN27_SEC_MASK` reader - Secure mask for pin P0_27"]
2320pub struct PIO0_PIN27_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN27_SEC_MASK_A>);
2321impl PIO0_PIN27_SEC_MASK_R {
2322 #[inline(always)]
2323 pub(crate) fn new(bits: bool) -> Self {
2324 PIO0_PIN27_SEC_MASK_R(crate::FieldReader::new(bits))
2325 }
2326 #[doc = r"Get enumerated values variant"]
2327 #[inline(always)]
2328 pub fn variant(&self) -> PIO0_PIN27_SEC_MASK_A {
2329 match self.bits {
2330 false => PIO0_PIN27_SEC_MASK_A::BLOCKED,
2331 true => PIO0_PIN27_SEC_MASK_A::READABLE,
2332 }
2333 }
2334 #[doc = "Checks if the value of the field is `BLOCKED`"]
2335 #[inline(always)]
2336 pub fn is_blocked(&self) -> bool {
2337 **self == PIO0_PIN27_SEC_MASK_A::BLOCKED
2338 }
2339 #[doc = "Checks if the value of the field is `READABLE`"]
2340 #[inline(always)]
2341 pub fn is_readable(&self) -> bool {
2342 **self == PIO0_PIN27_SEC_MASK_A::READABLE
2343 }
2344}
2345impl core::ops::Deref for PIO0_PIN27_SEC_MASK_R {
2346 type Target = crate::FieldReader<bool, PIO0_PIN27_SEC_MASK_A>;
2347 #[inline(always)]
2348 fn deref(&self) -> &Self::Target {
2349 &self.0
2350 }
2351}
2352#[doc = "Field `PIO0_PIN27_SEC_MASK` writer - Secure mask for pin P0_27"]
2353pub struct PIO0_PIN27_SEC_MASK_W<'a> {
2354 w: &'a mut W,
2355}
2356impl<'a> PIO0_PIN27_SEC_MASK_W<'a> {
2357 #[doc = r"Writes `variant` to the field"]
2358 #[inline(always)]
2359 pub fn variant(self, variant: PIO0_PIN27_SEC_MASK_A) -> &'a mut W {
2360 self.bit(variant.into())
2361 }
2362 #[doc = "Pin state is blocked to non-secure world."]
2363 #[inline(always)]
2364 pub fn blocked(self) -> &'a mut W {
2365 self.variant(PIO0_PIN27_SEC_MASK_A::BLOCKED)
2366 }
2367 #[doc = "Pin state is readable by non-secure world."]
2368 #[inline(always)]
2369 pub fn readable(self) -> &'a mut W {
2370 self.variant(PIO0_PIN27_SEC_MASK_A::READABLE)
2371 }
2372 #[doc = r"Sets the field bit"]
2373 #[inline(always)]
2374 pub fn set_bit(self) -> &'a mut W {
2375 self.bit(true)
2376 }
2377 #[doc = r"Clears the field bit"]
2378 #[inline(always)]
2379 pub fn clear_bit(self) -> &'a mut W {
2380 self.bit(false)
2381 }
2382 #[doc = r"Writes raw bits to the field"]
2383 #[inline(always)]
2384 pub fn bit(self, value: bool) -> &'a mut W {
2385 self.w.bits = (self.w.bits & !(0x01 << 27)) | ((value as u32 & 0x01) << 27);
2386 self.w
2387 }
2388}
2389#[doc = "Secure mask for pin P0_28\n\nValue on reset: 1"]
2390#[derive(Clone, Copy, Debug, PartialEq)]
2391pub enum PIO0_PIN28_SEC_MASK_A {
2392 #[doc = "0: Pin state is blocked to non-secure world."]
2393 BLOCKED = 0,
2394 #[doc = "1: Pin state is readable by non-secure world."]
2395 READABLE = 1,
2396}
2397impl From<PIO0_PIN28_SEC_MASK_A> for bool {
2398 #[inline(always)]
2399 fn from(variant: PIO0_PIN28_SEC_MASK_A) -> Self {
2400 variant as u8 != 0
2401 }
2402}
2403#[doc = "Field `PIO0_PIN28_SEC_MASK` reader - Secure mask for pin P0_28"]
2404pub struct PIO0_PIN28_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN28_SEC_MASK_A>);
2405impl PIO0_PIN28_SEC_MASK_R {
2406 #[inline(always)]
2407 pub(crate) fn new(bits: bool) -> Self {
2408 PIO0_PIN28_SEC_MASK_R(crate::FieldReader::new(bits))
2409 }
2410 #[doc = r"Get enumerated values variant"]
2411 #[inline(always)]
2412 pub fn variant(&self) -> PIO0_PIN28_SEC_MASK_A {
2413 match self.bits {
2414 false => PIO0_PIN28_SEC_MASK_A::BLOCKED,
2415 true => PIO0_PIN28_SEC_MASK_A::READABLE,
2416 }
2417 }
2418 #[doc = "Checks if the value of the field is `BLOCKED`"]
2419 #[inline(always)]
2420 pub fn is_blocked(&self) -> bool {
2421 **self == PIO0_PIN28_SEC_MASK_A::BLOCKED
2422 }
2423 #[doc = "Checks if the value of the field is `READABLE`"]
2424 #[inline(always)]
2425 pub fn is_readable(&self) -> bool {
2426 **self == PIO0_PIN28_SEC_MASK_A::READABLE
2427 }
2428}
2429impl core::ops::Deref for PIO0_PIN28_SEC_MASK_R {
2430 type Target = crate::FieldReader<bool, PIO0_PIN28_SEC_MASK_A>;
2431 #[inline(always)]
2432 fn deref(&self) -> &Self::Target {
2433 &self.0
2434 }
2435}
2436#[doc = "Field `PIO0_PIN28_SEC_MASK` writer - Secure mask for pin P0_28"]
2437pub struct PIO0_PIN28_SEC_MASK_W<'a> {
2438 w: &'a mut W,
2439}
2440impl<'a> PIO0_PIN28_SEC_MASK_W<'a> {
2441 #[doc = r"Writes `variant` to the field"]
2442 #[inline(always)]
2443 pub fn variant(self, variant: PIO0_PIN28_SEC_MASK_A) -> &'a mut W {
2444 self.bit(variant.into())
2445 }
2446 #[doc = "Pin state is blocked to non-secure world."]
2447 #[inline(always)]
2448 pub fn blocked(self) -> &'a mut W {
2449 self.variant(PIO0_PIN28_SEC_MASK_A::BLOCKED)
2450 }
2451 #[doc = "Pin state is readable by non-secure world."]
2452 #[inline(always)]
2453 pub fn readable(self) -> &'a mut W {
2454 self.variant(PIO0_PIN28_SEC_MASK_A::READABLE)
2455 }
2456 #[doc = r"Sets the field bit"]
2457 #[inline(always)]
2458 pub fn set_bit(self) -> &'a mut W {
2459 self.bit(true)
2460 }
2461 #[doc = r"Clears the field bit"]
2462 #[inline(always)]
2463 pub fn clear_bit(self) -> &'a mut W {
2464 self.bit(false)
2465 }
2466 #[doc = r"Writes raw bits to the field"]
2467 #[inline(always)]
2468 pub fn bit(self, value: bool) -> &'a mut W {
2469 self.w.bits = (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
2470 self.w
2471 }
2472}
2473#[doc = "Secure mask for pin P0_29\n\nValue on reset: 1"]
2474#[derive(Clone, Copy, Debug, PartialEq)]
2475pub enum PIO0_PIN29_SEC_MASK_A {
2476 #[doc = "0: Pin state is blocked to non-secure world."]
2477 BLOCKED = 0,
2478 #[doc = "1: Pin state is readable by non-secure world."]
2479 READABLE = 1,
2480}
2481impl From<PIO0_PIN29_SEC_MASK_A> for bool {
2482 #[inline(always)]
2483 fn from(variant: PIO0_PIN29_SEC_MASK_A) -> Self {
2484 variant as u8 != 0
2485 }
2486}
2487#[doc = "Field `PIO0_PIN29_SEC_MASK` reader - Secure mask for pin P0_29"]
2488pub struct PIO0_PIN29_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN29_SEC_MASK_A>);
2489impl PIO0_PIN29_SEC_MASK_R {
2490 #[inline(always)]
2491 pub(crate) fn new(bits: bool) -> Self {
2492 PIO0_PIN29_SEC_MASK_R(crate::FieldReader::new(bits))
2493 }
2494 #[doc = r"Get enumerated values variant"]
2495 #[inline(always)]
2496 pub fn variant(&self) -> PIO0_PIN29_SEC_MASK_A {
2497 match self.bits {
2498 false => PIO0_PIN29_SEC_MASK_A::BLOCKED,
2499 true => PIO0_PIN29_SEC_MASK_A::READABLE,
2500 }
2501 }
2502 #[doc = "Checks if the value of the field is `BLOCKED`"]
2503 #[inline(always)]
2504 pub fn is_blocked(&self) -> bool {
2505 **self == PIO0_PIN29_SEC_MASK_A::BLOCKED
2506 }
2507 #[doc = "Checks if the value of the field is `READABLE`"]
2508 #[inline(always)]
2509 pub fn is_readable(&self) -> bool {
2510 **self == PIO0_PIN29_SEC_MASK_A::READABLE
2511 }
2512}
2513impl core::ops::Deref for PIO0_PIN29_SEC_MASK_R {
2514 type Target = crate::FieldReader<bool, PIO0_PIN29_SEC_MASK_A>;
2515 #[inline(always)]
2516 fn deref(&self) -> &Self::Target {
2517 &self.0
2518 }
2519}
2520#[doc = "Field `PIO0_PIN29_SEC_MASK` writer - Secure mask for pin P0_29"]
2521pub struct PIO0_PIN29_SEC_MASK_W<'a> {
2522 w: &'a mut W,
2523}
2524impl<'a> PIO0_PIN29_SEC_MASK_W<'a> {
2525 #[doc = r"Writes `variant` to the field"]
2526 #[inline(always)]
2527 pub fn variant(self, variant: PIO0_PIN29_SEC_MASK_A) -> &'a mut W {
2528 self.bit(variant.into())
2529 }
2530 #[doc = "Pin state is blocked to non-secure world."]
2531 #[inline(always)]
2532 pub fn blocked(self) -> &'a mut W {
2533 self.variant(PIO0_PIN29_SEC_MASK_A::BLOCKED)
2534 }
2535 #[doc = "Pin state is readable by non-secure world."]
2536 #[inline(always)]
2537 pub fn readable(self) -> &'a mut W {
2538 self.variant(PIO0_PIN29_SEC_MASK_A::READABLE)
2539 }
2540 #[doc = r"Sets the field bit"]
2541 #[inline(always)]
2542 pub fn set_bit(self) -> &'a mut W {
2543 self.bit(true)
2544 }
2545 #[doc = r"Clears the field bit"]
2546 #[inline(always)]
2547 pub fn clear_bit(self) -> &'a mut W {
2548 self.bit(false)
2549 }
2550 #[doc = r"Writes raw bits to the field"]
2551 #[inline(always)]
2552 pub fn bit(self, value: bool) -> &'a mut W {
2553 self.w.bits = (self.w.bits & !(0x01 << 29)) | ((value as u32 & 0x01) << 29);
2554 self.w
2555 }
2556}
2557#[doc = "Secure mask for pin P0_30\n\nValue on reset: 1"]
2558#[derive(Clone, Copy, Debug, PartialEq)]
2559pub enum PIO0_PIN30_SEC_MASK_A {
2560 #[doc = "0: Pin state is blocked to non-secure world."]
2561 BLOCKED = 0,
2562 #[doc = "1: Pin state is readable by non-secure world."]
2563 READABLE = 1,
2564}
2565impl From<PIO0_PIN30_SEC_MASK_A> for bool {
2566 #[inline(always)]
2567 fn from(variant: PIO0_PIN30_SEC_MASK_A) -> Self {
2568 variant as u8 != 0
2569 }
2570}
2571#[doc = "Field `PIO0_PIN30_SEC_MASK` reader - Secure mask for pin P0_30"]
2572pub struct PIO0_PIN30_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN30_SEC_MASK_A>);
2573impl PIO0_PIN30_SEC_MASK_R {
2574 #[inline(always)]
2575 pub(crate) fn new(bits: bool) -> Self {
2576 PIO0_PIN30_SEC_MASK_R(crate::FieldReader::new(bits))
2577 }
2578 #[doc = r"Get enumerated values variant"]
2579 #[inline(always)]
2580 pub fn variant(&self) -> PIO0_PIN30_SEC_MASK_A {
2581 match self.bits {
2582 false => PIO0_PIN30_SEC_MASK_A::BLOCKED,
2583 true => PIO0_PIN30_SEC_MASK_A::READABLE,
2584 }
2585 }
2586 #[doc = "Checks if the value of the field is `BLOCKED`"]
2587 #[inline(always)]
2588 pub fn is_blocked(&self) -> bool {
2589 **self == PIO0_PIN30_SEC_MASK_A::BLOCKED
2590 }
2591 #[doc = "Checks if the value of the field is `READABLE`"]
2592 #[inline(always)]
2593 pub fn is_readable(&self) -> bool {
2594 **self == PIO0_PIN30_SEC_MASK_A::READABLE
2595 }
2596}
2597impl core::ops::Deref for PIO0_PIN30_SEC_MASK_R {
2598 type Target = crate::FieldReader<bool, PIO0_PIN30_SEC_MASK_A>;
2599 #[inline(always)]
2600 fn deref(&self) -> &Self::Target {
2601 &self.0
2602 }
2603}
2604#[doc = "Field `PIO0_PIN30_SEC_MASK` writer - Secure mask for pin P0_30"]
2605pub struct PIO0_PIN30_SEC_MASK_W<'a> {
2606 w: &'a mut W,
2607}
2608impl<'a> PIO0_PIN30_SEC_MASK_W<'a> {
2609 #[doc = r"Writes `variant` to the field"]
2610 #[inline(always)]
2611 pub fn variant(self, variant: PIO0_PIN30_SEC_MASK_A) -> &'a mut W {
2612 self.bit(variant.into())
2613 }
2614 #[doc = "Pin state is blocked to non-secure world."]
2615 #[inline(always)]
2616 pub fn blocked(self) -> &'a mut W {
2617 self.variant(PIO0_PIN30_SEC_MASK_A::BLOCKED)
2618 }
2619 #[doc = "Pin state is readable by non-secure world."]
2620 #[inline(always)]
2621 pub fn readable(self) -> &'a mut W {
2622 self.variant(PIO0_PIN30_SEC_MASK_A::READABLE)
2623 }
2624 #[doc = r"Sets the field bit"]
2625 #[inline(always)]
2626 pub fn set_bit(self) -> &'a mut W {
2627 self.bit(true)
2628 }
2629 #[doc = r"Clears the field bit"]
2630 #[inline(always)]
2631 pub fn clear_bit(self) -> &'a mut W {
2632 self.bit(false)
2633 }
2634 #[doc = r"Writes raw bits to the field"]
2635 #[inline(always)]
2636 pub fn bit(self, value: bool) -> &'a mut W {
2637 self.w.bits = (self.w.bits & !(0x01 << 30)) | ((value as u32 & 0x01) << 30);
2638 self.w
2639 }
2640}
2641#[doc = "Secure mask for pin P0_31\n\nValue on reset: 1"]
2642#[derive(Clone, Copy, Debug, PartialEq)]
2643pub enum PIO0_PIN31_SEC_MASK_A {
2644 #[doc = "0: Pin state is blocked to non-secure world."]
2645 BLOCKED = 0,
2646 #[doc = "1: Pin state is readable by non-secure world."]
2647 READABLE = 1,
2648}
2649impl From<PIO0_PIN31_SEC_MASK_A> for bool {
2650 #[inline(always)]
2651 fn from(variant: PIO0_PIN31_SEC_MASK_A) -> Self {
2652 variant as u8 != 0
2653 }
2654}
2655#[doc = "Field `PIO0_PIN31_SEC_MASK` reader - Secure mask for pin P0_31"]
2656pub struct PIO0_PIN31_SEC_MASK_R(crate::FieldReader<bool, PIO0_PIN31_SEC_MASK_A>);
2657impl PIO0_PIN31_SEC_MASK_R {
2658 #[inline(always)]
2659 pub(crate) fn new(bits: bool) -> Self {
2660 PIO0_PIN31_SEC_MASK_R(crate::FieldReader::new(bits))
2661 }
2662 #[doc = r"Get enumerated values variant"]
2663 #[inline(always)]
2664 pub fn variant(&self) -> PIO0_PIN31_SEC_MASK_A {
2665 match self.bits {
2666 false => PIO0_PIN31_SEC_MASK_A::BLOCKED,
2667 true => PIO0_PIN31_SEC_MASK_A::READABLE,
2668 }
2669 }
2670 #[doc = "Checks if the value of the field is `BLOCKED`"]
2671 #[inline(always)]
2672 pub fn is_blocked(&self) -> bool {
2673 **self == PIO0_PIN31_SEC_MASK_A::BLOCKED
2674 }
2675 #[doc = "Checks if the value of the field is `READABLE`"]
2676 #[inline(always)]
2677 pub fn is_readable(&self) -> bool {
2678 **self == PIO0_PIN31_SEC_MASK_A::READABLE
2679 }
2680}
2681impl core::ops::Deref for PIO0_PIN31_SEC_MASK_R {
2682 type Target = crate::FieldReader<bool, PIO0_PIN31_SEC_MASK_A>;
2683 #[inline(always)]
2684 fn deref(&self) -> &Self::Target {
2685 &self.0
2686 }
2687}
2688#[doc = "Field `PIO0_PIN31_SEC_MASK` writer - Secure mask for pin P0_31"]
2689pub struct PIO0_PIN31_SEC_MASK_W<'a> {
2690 w: &'a mut W,
2691}
2692impl<'a> PIO0_PIN31_SEC_MASK_W<'a> {
2693 #[doc = r"Writes `variant` to the field"]
2694 #[inline(always)]
2695 pub fn variant(self, variant: PIO0_PIN31_SEC_MASK_A) -> &'a mut W {
2696 self.bit(variant.into())
2697 }
2698 #[doc = "Pin state is blocked to non-secure world."]
2699 #[inline(always)]
2700 pub fn blocked(self) -> &'a mut W {
2701 self.variant(PIO0_PIN31_SEC_MASK_A::BLOCKED)
2702 }
2703 #[doc = "Pin state is readable by non-secure world."]
2704 #[inline(always)]
2705 pub fn readable(self) -> &'a mut W {
2706 self.variant(PIO0_PIN31_SEC_MASK_A::READABLE)
2707 }
2708 #[doc = r"Sets the field bit"]
2709 #[inline(always)]
2710 pub fn set_bit(self) -> &'a mut W {
2711 self.bit(true)
2712 }
2713 #[doc = r"Clears the field bit"]
2714 #[inline(always)]
2715 pub fn clear_bit(self) -> &'a mut W {
2716 self.bit(false)
2717 }
2718 #[doc = r"Writes raw bits to the field"]
2719 #[inline(always)]
2720 pub fn bit(self, value: bool) -> &'a mut W {
2721 self.w.bits = (self.w.bits & !(0x01 << 31)) | ((value as u32 & 0x01) << 31);
2722 self.w
2723 }
2724}
2725impl R {
2726 #[doc = "Bit 0 - Secure mask for pin P0_0"]
2727 #[inline(always)]
2728 pub fn pio0_pin0_sec_mask(&self) -> PIO0_PIN0_SEC_MASK_R {
2729 PIO0_PIN0_SEC_MASK_R::new((self.bits & 0x01) != 0)
2730 }
2731 #[doc = "Bit 1 - Secure mask for pin P0_1"]
2732 #[inline(always)]
2733 pub fn pio0_pin1_sec_mask(&self) -> PIO0_PIN1_SEC_MASK_R {
2734 PIO0_PIN1_SEC_MASK_R::new(((self.bits >> 1) & 0x01) != 0)
2735 }
2736 #[doc = "Bit 2 - Secure mask for pin P0_2"]
2737 #[inline(always)]
2738 pub fn pio0_pin2_sec_mask(&self) -> PIO0_PIN2_SEC_MASK_R {
2739 PIO0_PIN2_SEC_MASK_R::new(((self.bits >> 2) & 0x01) != 0)
2740 }
2741 #[doc = "Bit 3 - Secure mask for pin P0_3"]
2742 #[inline(always)]
2743 pub fn pio0_pin3_sec_mask(&self) -> PIO0_PIN3_SEC_MASK_R {
2744 PIO0_PIN3_SEC_MASK_R::new(((self.bits >> 3) & 0x01) != 0)
2745 }
2746 #[doc = "Bit 4 - Secure mask for pin P0_4"]
2747 #[inline(always)]
2748 pub fn pio0_pin4_sec_mask(&self) -> PIO0_PIN4_SEC_MASK_R {
2749 PIO0_PIN4_SEC_MASK_R::new(((self.bits >> 4) & 0x01) != 0)
2750 }
2751 #[doc = "Bit 5 - Secure mask for pin P0_5"]
2752 #[inline(always)]
2753 pub fn pio0_pin5_sec_mask(&self) -> PIO0_PIN5_SEC_MASK_R {
2754 PIO0_PIN5_SEC_MASK_R::new(((self.bits >> 5) & 0x01) != 0)
2755 }
2756 #[doc = "Bit 6 - Secure mask for pin P0_6"]
2757 #[inline(always)]
2758 pub fn pio0_pin6_sec_mask(&self) -> PIO0_PIN6_SEC_MASK_R {
2759 PIO0_PIN6_SEC_MASK_R::new(((self.bits >> 6) & 0x01) != 0)
2760 }
2761 #[doc = "Bit 7 - Secure mask for pin P0_7"]
2762 #[inline(always)]
2763 pub fn pio0_pin7_sec_mask(&self) -> PIO0_PIN7_SEC_MASK_R {
2764 PIO0_PIN7_SEC_MASK_R::new(((self.bits >> 7) & 0x01) != 0)
2765 }
2766 #[doc = "Bit 8 - Secure mask for pin P0_8"]
2767 #[inline(always)]
2768 pub fn pio0_pin8_sec_mask(&self) -> PIO0_PIN8_SEC_MASK_R {
2769 PIO0_PIN8_SEC_MASK_R::new(((self.bits >> 8) & 0x01) != 0)
2770 }
2771 #[doc = "Bit 9 - Secure mask for pin P0_9"]
2772 #[inline(always)]
2773 pub fn pio0_pin9_sec_mask(&self) -> PIO0_PIN9_SEC_MASK_R {
2774 PIO0_PIN9_SEC_MASK_R::new(((self.bits >> 9) & 0x01) != 0)
2775 }
2776 #[doc = "Bit 10 - Secure mask for pin P0_10"]
2777 #[inline(always)]
2778 pub fn pio0_pin10_sec_mask(&self) -> PIO0_PIN10_SEC_MASK_R {
2779 PIO0_PIN10_SEC_MASK_R::new(((self.bits >> 10) & 0x01) != 0)
2780 }
2781 #[doc = "Bit 11 - Secure mask for pin P0_11"]
2782 #[inline(always)]
2783 pub fn pio0_pin11_sec_mask(&self) -> PIO0_PIN11_SEC_MASK_R {
2784 PIO0_PIN11_SEC_MASK_R::new(((self.bits >> 11) & 0x01) != 0)
2785 }
2786 #[doc = "Bit 12 - Secure mask for pin P0_12"]
2787 #[inline(always)]
2788 pub fn pio0_pin12_sec_mask(&self) -> PIO0_PIN12_SEC_MASK_R {
2789 PIO0_PIN12_SEC_MASK_R::new(((self.bits >> 12) & 0x01) != 0)
2790 }
2791 #[doc = "Bit 13 - Secure mask for pin P0_13"]
2792 #[inline(always)]
2793 pub fn pio0_pin13_sec_mask(&self) -> PIO0_PIN13_SEC_MASK_R {
2794 PIO0_PIN13_SEC_MASK_R::new(((self.bits >> 13) & 0x01) != 0)
2795 }
2796 #[doc = "Bit 14 - Secure mask for pin P0_14"]
2797 #[inline(always)]
2798 pub fn pio0_pin14_sec_mask(&self) -> PIO0_PIN14_SEC_MASK_R {
2799 PIO0_PIN14_SEC_MASK_R::new(((self.bits >> 14) & 0x01) != 0)
2800 }
2801 #[doc = "Bit 15 - Secure mask for pin P0_15"]
2802 #[inline(always)]
2803 pub fn pio0_pin15_sec_mask(&self) -> PIO0_PIN15_SEC_MASK_R {
2804 PIO0_PIN15_SEC_MASK_R::new(((self.bits >> 15) & 0x01) != 0)
2805 }
2806 #[doc = "Bit 16 - Secure mask for pin P0_16"]
2807 #[inline(always)]
2808 pub fn pio0_pin16_sec_mask(&self) -> PIO0_PIN16_SEC_MASK_R {
2809 PIO0_PIN16_SEC_MASK_R::new(((self.bits >> 16) & 0x01) != 0)
2810 }
2811 #[doc = "Bit 17 - Secure mask for pin P0_17"]
2812 #[inline(always)]
2813 pub fn pio0_pin17_sec_mask(&self) -> PIO0_PIN17_SEC_MASK_R {
2814 PIO0_PIN17_SEC_MASK_R::new(((self.bits >> 17) & 0x01) != 0)
2815 }
2816 #[doc = "Bit 18 - Secure mask for pin P0_18"]
2817 #[inline(always)]
2818 pub fn pio0_pin18_sec_mask(&self) -> PIO0_PIN18_SEC_MASK_R {
2819 PIO0_PIN18_SEC_MASK_R::new(((self.bits >> 18) & 0x01) != 0)
2820 }
2821 #[doc = "Bit 19 - Secure mask for pin P0_19"]
2822 #[inline(always)]
2823 pub fn pio0_pin19_sec_mask(&self) -> PIO0_PIN19_SEC_MASK_R {
2824 PIO0_PIN19_SEC_MASK_R::new(((self.bits >> 19) & 0x01) != 0)
2825 }
2826 #[doc = "Bit 20 - Secure mask for pin P0_20"]
2827 #[inline(always)]
2828 pub fn pio0_pin20_sec_mask(&self) -> PIO0_PIN20_SEC_MASK_R {
2829 PIO0_PIN20_SEC_MASK_R::new(((self.bits >> 20) & 0x01) != 0)
2830 }
2831 #[doc = "Bit 21 - Secure mask for pin P0_21"]
2832 #[inline(always)]
2833 pub fn pio0_pin21_sec_mask(&self) -> PIO0_PIN21_SEC_MASK_R {
2834 PIO0_PIN21_SEC_MASK_R::new(((self.bits >> 21) & 0x01) != 0)
2835 }
2836 #[doc = "Bit 22 - Secure mask for pin P0_22"]
2837 #[inline(always)]
2838 pub fn pio0_pin22_sec_mask(&self) -> PIO0_PIN22_SEC_MASK_R {
2839 PIO0_PIN22_SEC_MASK_R::new(((self.bits >> 22) & 0x01) != 0)
2840 }
2841 #[doc = "Bit 23 - Secure mask for pin P0_23"]
2842 #[inline(always)]
2843 pub fn pio0_pin23_sec_mask(&self) -> PIO0_PIN23_SEC_MASK_R {
2844 PIO0_PIN23_SEC_MASK_R::new(((self.bits >> 23) & 0x01) != 0)
2845 }
2846 #[doc = "Bit 24 - Secure mask for pin P0_24"]
2847 #[inline(always)]
2848 pub fn pio0_pin24_sec_mask(&self) -> PIO0_PIN24_SEC_MASK_R {
2849 PIO0_PIN24_SEC_MASK_R::new(((self.bits >> 24) & 0x01) != 0)
2850 }
2851 #[doc = "Bit 25 - Secure mask for pin P0_25"]
2852 #[inline(always)]
2853 pub fn pio0_pin25_sec_mask(&self) -> PIO0_PIN25_SEC_MASK_R {
2854 PIO0_PIN25_SEC_MASK_R::new(((self.bits >> 25) & 0x01) != 0)
2855 }
2856 #[doc = "Bit 26 - Secure mask for pin P0_26"]
2857 #[inline(always)]
2858 pub fn pio0_pin26_sec_mask(&self) -> PIO0_PIN26_SEC_MASK_R {
2859 PIO0_PIN26_SEC_MASK_R::new(((self.bits >> 26) & 0x01) != 0)
2860 }
2861 #[doc = "Bit 27 - Secure mask for pin P0_27"]
2862 #[inline(always)]
2863 pub fn pio0_pin27_sec_mask(&self) -> PIO0_PIN27_SEC_MASK_R {
2864 PIO0_PIN27_SEC_MASK_R::new(((self.bits >> 27) & 0x01) != 0)
2865 }
2866 #[doc = "Bit 28 - Secure mask for pin P0_28"]
2867 #[inline(always)]
2868 pub fn pio0_pin28_sec_mask(&self) -> PIO0_PIN28_SEC_MASK_R {
2869 PIO0_PIN28_SEC_MASK_R::new(((self.bits >> 28) & 0x01) != 0)
2870 }
2871 #[doc = "Bit 29 - Secure mask for pin P0_29"]
2872 #[inline(always)]
2873 pub fn pio0_pin29_sec_mask(&self) -> PIO0_PIN29_SEC_MASK_R {
2874 PIO0_PIN29_SEC_MASK_R::new(((self.bits >> 29) & 0x01) != 0)
2875 }
2876 #[doc = "Bit 30 - Secure mask for pin P0_30"]
2877 #[inline(always)]
2878 pub fn pio0_pin30_sec_mask(&self) -> PIO0_PIN30_SEC_MASK_R {
2879 PIO0_PIN30_SEC_MASK_R::new(((self.bits >> 30) & 0x01) != 0)
2880 }
2881 #[doc = "Bit 31 - Secure mask for pin P0_31"]
2882 #[inline(always)]
2883 pub fn pio0_pin31_sec_mask(&self) -> PIO0_PIN31_SEC_MASK_R {
2884 PIO0_PIN31_SEC_MASK_R::new(((self.bits >> 31) & 0x01) != 0)
2885 }
2886}
2887impl W {
2888 #[doc = "Bit 0 - Secure mask for pin P0_0"]
2889 #[inline(always)]
2890 pub fn pio0_pin0_sec_mask(&mut self) -> PIO0_PIN0_SEC_MASK_W {
2891 PIO0_PIN0_SEC_MASK_W { w: self }
2892 }
2893 #[doc = "Bit 1 - Secure mask for pin P0_1"]
2894 #[inline(always)]
2895 pub fn pio0_pin1_sec_mask(&mut self) -> PIO0_PIN1_SEC_MASK_W {
2896 PIO0_PIN1_SEC_MASK_W { w: self }
2897 }
2898 #[doc = "Bit 2 - Secure mask for pin P0_2"]
2899 #[inline(always)]
2900 pub fn pio0_pin2_sec_mask(&mut self) -> PIO0_PIN2_SEC_MASK_W {
2901 PIO0_PIN2_SEC_MASK_W { w: self }
2902 }
2903 #[doc = "Bit 3 - Secure mask for pin P0_3"]
2904 #[inline(always)]
2905 pub fn pio0_pin3_sec_mask(&mut self) -> PIO0_PIN3_SEC_MASK_W {
2906 PIO0_PIN3_SEC_MASK_W { w: self }
2907 }
2908 #[doc = "Bit 4 - Secure mask for pin P0_4"]
2909 #[inline(always)]
2910 pub fn pio0_pin4_sec_mask(&mut self) -> PIO0_PIN4_SEC_MASK_W {
2911 PIO0_PIN4_SEC_MASK_W { w: self }
2912 }
2913 #[doc = "Bit 5 - Secure mask for pin P0_5"]
2914 #[inline(always)]
2915 pub fn pio0_pin5_sec_mask(&mut self) -> PIO0_PIN5_SEC_MASK_W {
2916 PIO0_PIN5_SEC_MASK_W { w: self }
2917 }
2918 #[doc = "Bit 6 - Secure mask for pin P0_6"]
2919 #[inline(always)]
2920 pub fn pio0_pin6_sec_mask(&mut self) -> PIO0_PIN6_SEC_MASK_W {
2921 PIO0_PIN6_SEC_MASK_W { w: self }
2922 }
2923 #[doc = "Bit 7 - Secure mask for pin P0_7"]
2924 #[inline(always)]
2925 pub fn pio0_pin7_sec_mask(&mut self) -> PIO0_PIN7_SEC_MASK_W {
2926 PIO0_PIN7_SEC_MASK_W { w: self }
2927 }
2928 #[doc = "Bit 8 - Secure mask for pin P0_8"]
2929 #[inline(always)]
2930 pub fn pio0_pin8_sec_mask(&mut self) -> PIO0_PIN8_SEC_MASK_W {
2931 PIO0_PIN8_SEC_MASK_W { w: self }
2932 }
2933 #[doc = "Bit 9 - Secure mask for pin P0_9"]
2934 #[inline(always)]
2935 pub fn pio0_pin9_sec_mask(&mut self) -> PIO0_PIN9_SEC_MASK_W {
2936 PIO0_PIN9_SEC_MASK_W { w: self }
2937 }
2938 #[doc = "Bit 10 - Secure mask for pin P0_10"]
2939 #[inline(always)]
2940 pub fn pio0_pin10_sec_mask(&mut self) -> PIO0_PIN10_SEC_MASK_W {
2941 PIO0_PIN10_SEC_MASK_W { w: self }
2942 }
2943 #[doc = "Bit 11 - Secure mask for pin P0_11"]
2944 #[inline(always)]
2945 pub fn pio0_pin11_sec_mask(&mut self) -> PIO0_PIN11_SEC_MASK_W {
2946 PIO0_PIN11_SEC_MASK_W { w: self }
2947 }
2948 #[doc = "Bit 12 - Secure mask for pin P0_12"]
2949 #[inline(always)]
2950 pub fn pio0_pin12_sec_mask(&mut self) -> PIO0_PIN12_SEC_MASK_W {
2951 PIO0_PIN12_SEC_MASK_W { w: self }
2952 }
2953 #[doc = "Bit 13 - Secure mask for pin P0_13"]
2954 #[inline(always)]
2955 pub fn pio0_pin13_sec_mask(&mut self) -> PIO0_PIN13_SEC_MASK_W {
2956 PIO0_PIN13_SEC_MASK_W { w: self }
2957 }
2958 #[doc = "Bit 14 - Secure mask for pin P0_14"]
2959 #[inline(always)]
2960 pub fn pio0_pin14_sec_mask(&mut self) -> PIO0_PIN14_SEC_MASK_W {
2961 PIO0_PIN14_SEC_MASK_W { w: self }
2962 }
2963 #[doc = "Bit 15 - Secure mask for pin P0_15"]
2964 #[inline(always)]
2965 pub fn pio0_pin15_sec_mask(&mut self) -> PIO0_PIN15_SEC_MASK_W {
2966 PIO0_PIN15_SEC_MASK_W { w: self }
2967 }
2968 #[doc = "Bit 16 - Secure mask for pin P0_16"]
2969 #[inline(always)]
2970 pub fn pio0_pin16_sec_mask(&mut self) -> PIO0_PIN16_SEC_MASK_W {
2971 PIO0_PIN16_SEC_MASK_W { w: self }
2972 }
2973 #[doc = "Bit 17 - Secure mask for pin P0_17"]
2974 #[inline(always)]
2975 pub fn pio0_pin17_sec_mask(&mut self) -> PIO0_PIN17_SEC_MASK_W {
2976 PIO0_PIN17_SEC_MASK_W { w: self }
2977 }
2978 #[doc = "Bit 18 - Secure mask for pin P0_18"]
2979 #[inline(always)]
2980 pub fn pio0_pin18_sec_mask(&mut self) -> PIO0_PIN18_SEC_MASK_W {
2981 PIO0_PIN18_SEC_MASK_W { w: self }
2982 }
2983 #[doc = "Bit 19 - Secure mask for pin P0_19"]
2984 #[inline(always)]
2985 pub fn pio0_pin19_sec_mask(&mut self) -> PIO0_PIN19_SEC_MASK_W {
2986 PIO0_PIN19_SEC_MASK_W { w: self }
2987 }
2988 #[doc = "Bit 20 - Secure mask for pin P0_20"]
2989 #[inline(always)]
2990 pub fn pio0_pin20_sec_mask(&mut self) -> PIO0_PIN20_SEC_MASK_W {
2991 PIO0_PIN20_SEC_MASK_W { w: self }
2992 }
2993 #[doc = "Bit 21 - Secure mask for pin P0_21"]
2994 #[inline(always)]
2995 pub fn pio0_pin21_sec_mask(&mut self) -> PIO0_PIN21_SEC_MASK_W {
2996 PIO0_PIN21_SEC_MASK_W { w: self }
2997 }
2998 #[doc = "Bit 22 - Secure mask for pin P0_22"]
2999 #[inline(always)]
3000 pub fn pio0_pin22_sec_mask(&mut self) -> PIO0_PIN22_SEC_MASK_W {
3001 PIO0_PIN22_SEC_MASK_W { w: self }
3002 }
3003 #[doc = "Bit 23 - Secure mask for pin P0_23"]
3004 #[inline(always)]
3005 pub fn pio0_pin23_sec_mask(&mut self) -> PIO0_PIN23_SEC_MASK_W {
3006 PIO0_PIN23_SEC_MASK_W { w: self }
3007 }
3008 #[doc = "Bit 24 - Secure mask for pin P0_24"]
3009 #[inline(always)]
3010 pub fn pio0_pin24_sec_mask(&mut self) -> PIO0_PIN24_SEC_MASK_W {
3011 PIO0_PIN24_SEC_MASK_W { w: self }
3012 }
3013 #[doc = "Bit 25 - Secure mask for pin P0_25"]
3014 #[inline(always)]
3015 pub fn pio0_pin25_sec_mask(&mut self) -> PIO0_PIN25_SEC_MASK_W {
3016 PIO0_PIN25_SEC_MASK_W { w: self }
3017 }
3018 #[doc = "Bit 26 - Secure mask for pin P0_26"]
3019 #[inline(always)]
3020 pub fn pio0_pin26_sec_mask(&mut self) -> PIO0_PIN26_SEC_MASK_W {
3021 PIO0_PIN26_SEC_MASK_W { w: self }
3022 }
3023 #[doc = "Bit 27 - Secure mask for pin P0_27"]
3024 #[inline(always)]
3025 pub fn pio0_pin27_sec_mask(&mut self) -> PIO0_PIN27_SEC_MASK_W {
3026 PIO0_PIN27_SEC_MASK_W { w: self }
3027 }
3028 #[doc = "Bit 28 - Secure mask for pin P0_28"]
3029 #[inline(always)]
3030 pub fn pio0_pin28_sec_mask(&mut self) -> PIO0_PIN28_SEC_MASK_W {
3031 PIO0_PIN28_SEC_MASK_W { w: self }
3032 }
3033 #[doc = "Bit 29 - Secure mask for pin P0_29"]
3034 #[inline(always)]
3035 pub fn pio0_pin29_sec_mask(&mut self) -> PIO0_PIN29_SEC_MASK_W {
3036 PIO0_PIN29_SEC_MASK_W { w: self }
3037 }
3038 #[doc = "Bit 30 - Secure mask for pin P0_30"]
3039 #[inline(always)]
3040 pub fn pio0_pin30_sec_mask(&mut self) -> PIO0_PIN30_SEC_MASK_W {
3041 PIO0_PIN30_SEC_MASK_W { w: self }
3042 }
3043 #[doc = "Bit 31 - Secure mask for pin P0_31"]
3044 #[inline(always)]
3045 pub fn pio0_pin31_sec_mask(&mut self) -> PIO0_PIN31_SEC_MASK_W {
3046 PIO0_PIN31_SEC_MASK_W { w: self }
3047 }
3048 #[doc = "Writes raw bits to the register."]
3049 #[inline(always)]
3050 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
3051 self.0.bits(bits);
3052 self
3053 }
3054}
3055#[doc = "Secure GPIO mask for port 0 pins.\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 [sec_gpio_mask0](index.html) module"]
3056pub struct SEC_GPIO_MASK0_SPEC;
3057impl crate::RegisterSpec for SEC_GPIO_MASK0_SPEC {
3058 type Ux = u32;
3059}
3060#[doc = "`read()` method returns [sec_gpio_mask0::R](R) reader structure"]
3061impl crate::Readable for SEC_GPIO_MASK0_SPEC {
3062 type Reader = R;
3063}
3064#[doc = "`write(|w| ..)` method takes [sec_gpio_mask0::W](W) writer structure"]
3065impl crate::Writable for SEC_GPIO_MASK0_SPEC {
3066 type Writer = W;
3067}
3068#[doc = "`reset()` method sets SEC_GPIO_MASK0 to value 0xffff_ffff"]
3069impl crate::Resettable for SEC_GPIO_MASK0_SPEC {
3070 #[inline(always)]
3071 fn reset_value() -> Self::Ux {
3072 0xffff_ffff
3073 }
3074}