bl61x_pac/emac/
interrupt_source.rs

1#[doc = "Register `interrupt_source` reader"]
2pub type R = crate::R<INTERRUPT_SOURCE_SPEC>;
3#[doc = "Register `interrupt_source` writer"]
4pub type W = crate::W<INTERRUPT_SOURCE_SPEC>;
5#[doc = "Field `buffer_transmitted` reader - Buffer transmitted interrupt state"]
6pub use CONTROL_RECEIVE_R as BUFFER_TRANSMITTED_R;
7#[doc = "Field `transmit_error` reader - Transmit error interrupt state"]
8pub use CONTROL_RECEIVE_R as TRANSMIT_ERROR_R;
9#[doc = "Field `frame_received` reader - Frame received interrupt state"]
10pub use CONTROL_RECEIVE_R as FRAME_RECEIVED_R;
11#[doc = "Field `receive_error` reader - Receive error interrupt state"]
12pub use CONTROL_RECEIVE_R as RECEIVE_ERROR_R;
13#[doc = "Field `busy` reader - Lack of buffer interrupt state"]
14pub use CONTROL_RECEIVE_R as BUSY_R;
15#[doc = "Field `control_transmit` reader - Control frame transmitted interrupt state"]
16pub use CONTROL_RECEIVE_R as CONTROL_TRANSMIT_R;
17#[doc = "Field `buffer_transmitted` writer - Buffer transmitted interrupt state"]
18pub use CONTROL_RECEIVE_W as BUFFER_TRANSMITTED_W;
19#[doc = "Field `transmit_error` writer - Transmit error interrupt state"]
20pub use CONTROL_RECEIVE_W as TRANSMIT_ERROR_W;
21#[doc = "Field `frame_received` writer - Frame received interrupt state"]
22pub use CONTROL_RECEIVE_W as FRAME_RECEIVED_W;
23#[doc = "Field `receive_error` writer - Receive error interrupt state"]
24pub use CONTROL_RECEIVE_W as RECEIVE_ERROR_W;
25#[doc = "Field `busy` writer - Lack of buffer interrupt state"]
26pub use CONTROL_RECEIVE_W as BUSY_W;
27#[doc = "Field `control_transmit` writer - Control frame transmitted interrupt state"]
28pub use CONTROL_RECEIVE_W as CONTROL_TRANSMIT_W;
29#[doc = "Field `control_receive` reader - Control frame received interrupt state"]
30pub type CONTROL_RECEIVE_R = crate::BitReader<INTERRUPT_STATE_A>;
31#[doc = "Control frame received interrupt state\n\nValue on reset: 0"]
32#[derive(Clone, Copy, Debug, PartialEq, Eq)]
33pub enum INTERRUPT_STATE_A {
34    #[doc = "1: Has interrupt"]
35    HAS_INTERRUPT = 1,
36    #[doc = "0: No interrupt occurred"]
37    NO_INTERRUPT = 0,
38}
39impl From<INTERRUPT_STATE_A> for bool {
40    #[inline(always)]
41    fn from(variant: INTERRUPT_STATE_A) -> Self {
42        variant as u8 != 0
43    }
44}
45impl CONTROL_RECEIVE_R {
46    #[doc = "Get enumerated values variant"]
47    #[inline(always)]
48    pub const fn variant(&self) -> INTERRUPT_STATE_A {
49        match self.bits {
50            true => INTERRUPT_STATE_A::HAS_INTERRUPT,
51            false => INTERRUPT_STATE_A::NO_INTERRUPT,
52        }
53    }
54    #[doc = "Has interrupt"]
55    #[inline(always)]
56    pub fn is_has_interrupt(&self) -> bool {
57        *self == INTERRUPT_STATE_A::HAS_INTERRUPT
58    }
59    #[doc = "No interrupt occurred"]
60    #[inline(always)]
61    pub fn is_no_interrupt(&self) -> bool {
62        *self == INTERRUPT_STATE_A::NO_INTERRUPT
63    }
64}
65#[doc = "Field `control_receive` writer - Control frame received interrupt state"]
66pub type CONTROL_RECEIVE_W<'a, REG> = crate::BitWriter1C<'a, REG, INTERRUPT_STATE_A>;
67impl<'a, REG> CONTROL_RECEIVE_W<'a, REG>
68where
69    REG: crate::Writable + crate::RegisterSpec,
70{
71    #[doc = "Has interrupt"]
72    #[inline(always)]
73    pub fn has_interrupt(self) -> &'a mut crate::W<REG> {
74        self.variant(INTERRUPT_STATE_A::HAS_INTERRUPT)
75    }
76    #[doc = "No interrupt occurred"]
77    #[inline(always)]
78    pub fn no_interrupt(self) -> &'a mut crate::W<REG> {
79        self.variant(INTERRUPT_STATE_A::NO_INTERRUPT)
80    }
81}
82impl R {
83    #[doc = "Bit 0 - Buffer transmitted interrupt state"]
84    #[inline(always)]
85    pub fn buffer_transmitted(&self) -> BUFFER_TRANSMITTED_R {
86        BUFFER_TRANSMITTED_R::new((self.bits & 1) != 0)
87    }
88    #[doc = "Bit 1 - Transmit error interrupt state"]
89    #[inline(always)]
90    pub fn transmit_error(&self) -> TRANSMIT_ERROR_R {
91        TRANSMIT_ERROR_R::new(((self.bits >> 1) & 1) != 0)
92    }
93    #[doc = "Bit 2 - Frame received interrupt state"]
94    #[inline(always)]
95    pub fn frame_received(&self) -> FRAME_RECEIVED_R {
96        FRAME_RECEIVED_R::new(((self.bits >> 2) & 1) != 0)
97    }
98    #[doc = "Bit 3 - Receive error interrupt state"]
99    #[inline(always)]
100    pub fn receive_error(&self) -> RECEIVE_ERROR_R {
101        RECEIVE_ERROR_R::new(((self.bits >> 3) & 1) != 0)
102    }
103    #[doc = "Bit 4 - Lack of buffer interrupt state"]
104    #[inline(always)]
105    pub fn busy(&self) -> BUSY_R {
106        BUSY_R::new(((self.bits >> 4) & 1) != 0)
107    }
108    #[doc = "Bit 5 - Control frame transmitted interrupt state"]
109    #[inline(always)]
110    pub fn control_transmit(&self) -> CONTROL_TRANSMIT_R {
111        CONTROL_TRANSMIT_R::new(((self.bits >> 5) & 1) != 0)
112    }
113    #[doc = "Bit 6 - Control frame received interrupt state"]
114    #[inline(always)]
115    pub fn control_receive(&self) -> CONTROL_RECEIVE_R {
116        CONTROL_RECEIVE_R::new(((self.bits >> 6) & 1) != 0)
117    }
118}
119impl W {
120    #[doc = "Bit 0 - Buffer transmitted interrupt state"]
121    #[inline(always)]
122    #[must_use]
123    pub fn buffer_transmitted(&mut self) -> BUFFER_TRANSMITTED_W<INTERRUPT_SOURCE_SPEC> {
124        BUFFER_TRANSMITTED_W::new(self, 0)
125    }
126    #[doc = "Bit 1 - Transmit error interrupt state"]
127    #[inline(always)]
128    #[must_use]
129    pub fn transmit_error(&mut self) -> TRANSMIT_ERROR_W<INTERRUPT_SOURCE_SPEC> {
130        TRANSMIT_ERROR_W::new(self, 1)
131    }
132    #[doc = "Bit 2 - Frame received interrupt state"]
133    #[inline(always)]
134    #[must_use]
135    pub fn frame_received(&mut self) -> FRAME_RECEIVED_W<INTERRUPT_SOURCE_SPEC> {
136        FRAME_RECEIVED_W::new(self, 2)
137    }
138    #[doc = "Bit 3 - Receive error interrupt state"]
139    #[inline(always)]
140    #[must_use]
141    pub fn receive_error(&mut self) -> RECEIVE_ERROR_W<INTERRUPT_SOURCE_SPEC> {
142        RECEIVE_ERROR_W::new(self, 3)
143    }
144    #[doc = "Bit 4 - Lack of buffer interrupt state"]
145    #[inline(always)]
146    #[must_use]
147    pub fn busy(&mut self) -> BUSY_W<INTERRUPT_SOURCE_SPEC> {
148        BUSY_W::new(self, 4)
149    }
150    #[doc = "Bit 5 - Control frame transmitted interrupt state"]
151    #[inline(always)]
152    #[must_use]
153    pub fn control_transmit(&mut self) -> CONTROL_TRANSMIT_W<INTERRUPT_SOURCE_SPEC> {
154        CONTROL_TRANSMIT_W::new(self, 5)
155    }
156    #[doc = "Bit 6 - Control frame received interrupt state"]
157    #[inline(always)]
158    #[must_use]
159    pub fn control_receive(&mut self) -> CONTROL_RECEIVE_W<INTERRUPT_SOURCE_SPEC> {
160        CONTROL_RECEIVE_W::new(self, 6)
161    }
162    #[doc = r" Writes raw bits to the register."]
163    #[doc = r""]
164    #[doc = r" # Safety"]
165    #[doc = r""]
166    #[doc = r" Passing incorrect value can cause undefined behaviour. See reference manual"]
167    #[inline(always)]
168    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
169        self.bits = bits;
170        self
171    }
172}
173#[doc = "Interrupt source register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`interrupt_source::R`](R).  You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`interrupt_source::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
174pub struct INTERRUPT_SOURCE_SPEC;
175impl crate::RegisterSpec for INTERRUPT_SOURCE_SPEC {
176    type Ux = u32;
177}
178#[doc = "`read()` method returns [`interrupt_source::R`](R) reader structure"]
179impl crate::Readable for INTERRUPT_SOURCE_SPEC {}
180#[doc = "`write(|w| ..)` method takes [`interrupt_source::W`](W) writer structure"]
181impl crate::Writable for INTERRUPT_SOURCE_SPEC {
182    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
183    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0x7f;
184}
185#[doc = "`reset()` method sets interrupt_source to value 0"]
186impl crate::Resettable for INTERRUPT_SOURCE_SPEC {
187    const RESET_VALUE: Self::Ux = 0;
188}