├── .gitignore ├── svd └── patches │ └── esp32.yaml ├── src ├── wdev.rs ├── bb.rs ├── nrx.rs ├── flash_encryption.rs ├── frc_timer.rs ├── aes.rs ├── gpio │ ├── in_.rs │ ├── in1.rs │ ├── strap.rs │ ├── acpu_int.rs │ ├── pcpu_int.rs │ ├── cpusdio_int.rs │ ├── acpu_int1.rs │ └── pcpu_int1.rs ├── efuse │ ├── status.rs │ ├── blk1_rdata0.rs │ ├── blk1_rdata1.rs │ ├── blk1_rdata2.rs │ ├── blk1_rdata3.rs │ ├── blk1_rdata4.rs │ ├── blk1_rdata5.rs │ ├── blk1_rdata6.rs │ ├── blk1_rdata7.rs │ ├── blk2_rdata0.rs │ ├── blk2_rdata1.rs │ ├── blk2_rdata2.rs │ ├── blk2_rdata3.rs │ ├── blk2_rdata4.rs │ ├── blk2_rdata5.rs │ ├── blk2_rdata6.rs │ ├── blk2_rdata7.rs │ ├── blk3_rdata0.rs │ ├── blk3_rdata1.rs │ ├── blk3_rdata2.rs │ ├── blk3_rdata5.rs │ ├── blk3_rdata6.rs │ ├── blk3_rdata7.rs │ └── dec_status.rs ├── uhci0 │ ├── state0.rs │ ├── state1.rs │ ├── rx_head.rs │ └── dma_in_dscr.rs ├── rtcio │ └── in_.rs ├── timg0 │ ├── lacthi.rs │ ├── lactlo.rs │ ├── t0hi.rs │ ├── t0lo.rs │ ├── t1hi.rs │ ├── t1lo.rs │ └── rtccalicfg1.rs ├── spi0 │ ├── ext2.rs │ ├── date.rs │ ├── dma_tstatus.rs │ └── dma_rstatus.rs ├── pwm0 │ ├── cap_ch0.rs │ ├── cap_ch1.rs │ └── cap_ch2.rs ├── rtc_cntl │ ├── time0.rs │ ├── time1.rs │ └── diag1.rs ├── i2s0 │ ├── lc_state0.rs │ ├── lc_state1.rs │ ├── inlink_dscr.rs │ ├── outlink_dscr.rs │ ├── inlink_dscr_bf0.rs │ ├── inlink_dscr_bf1.rs │ ├── out_eof_des_addr.rs │ ├── outlink_dscr_bf0.rs │ ├── outlink_dscr_bf1.rs │ └── in_eof_des_addr.rs ├── slc │ ├── _0_length.rs │ ├── _0_state0.rs │ ├── _0_state1.rs │ ├── _1_state0.rs │ ├── _1_state1.rs │ ├── cmd_infor0.rs │ ├── cmd_infor1.rs │ ├── _0_rxlink_dscr.rs │ ├── _0_txlink_dscr.rs │ ├── _1_rxlink_dscr.rs │ └── _1_txlink_dscr.rs ├── sdmmc │ ├── resp0.rs │ ├── resp1.rs │ ├── resp2.rs │ ├── resp3.rs │ ├── tcbcnt.rs │ ├── tbbcnt.rs │ └── verid.rs ├── pcnt │ ├── u1_status.rs │ ├── u2_status.rs │ ├── u3_status.rs │ ├── u4_status.rs │ ├── u5_status.rs │ ├── u6_status.rs │ ├── u7_status.rs │ ├── u0_cnt.rs │ ├── u1_cnt.rs │ ├── u2_cnt.rs │ ├── u3_cnt.rs │ ├── u4_cnt.rs │ ├── u5_cnt.rs │ ├── u6_cnt.rs │ └── u7_cnt.rs ├── rsa │ └── clean.rs ├── flash_encryption │ └── done.rs ├── i2c0 │ └── data.rs ├── uart0 │ └── mem_tx_status.rs ├── aes │ └── idle.rs ├── rmt │ ├── ch0addr.rs │ ├── ch1addr.rs │ ├── ch2addr.rs │ ├── ch3addr.rs │ ├── ch4addr.rs │ ├── ch5addr.rs │ ├── ch6addr.rs │ └── ch7addr.rs └── dport │ ├── app_dcache_dbug2.rs │ ├── pro_dcache_dbug2.rs │ └── app_cpu_record_pid.rs ├── .travis.yml ├── Makefile ├── Cargo.toml ├── LICENSE-MIT └── device.x /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | **/*.rs.bk 3 | Cargo.lock 4 | svd/esp32.svd 5 | -------------------------------------------------------------------------------- /svd/patches/esp32.yaml: -------------------------------------------------------------------------------- 1 | _svd: ../esp32.base.svd 2 | 3 | UART0: 4 | FIFO: 5 | _modify: 6 | RXFIFO_RD_BYTE: 7 | access: read-write 8 | -------------------------------------------------------------------------------- /src/wdev.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | #[doc = "0x00 - Hardware random number generator register"] 5 | pub rnd: crate::Reg, 6 | } 7 | #[doc = "RND register accessor: an alias for `Reg`"] 8 | pub type RND = crate::Reg; 9 | #[doc = "Hardware random number generator register"] 10 | pub mod rnd; 11 | -------------------------------------------------------------------------------- /src/bb.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | _reserved0: [u8; 0x54], 5 | #[doc = "0x54 - Baseband control register"] 6 | pub bbpd_ctrl: crate::Reg, 7 | } 8 | #[doc = "BBPD_CTRL register accessor: an alias for `Reg`"] 9 | pub type BBPD_CTRL = crate::Reg; 10 | #[doc = "Baseband control register"] 11 | pub mod bbpd_ctrl; 12 | -------------------------------------------------------------------------------- /src/nrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | _reserved0: [u8; 0xd4], 5 | #[doc = "0xd4 - WiFi RX control register"] 6 | pub nrxpd_ctrl: crate::Reg, 7 | } 8 | #[doc = "NRXPD_CTRL register accessor: an alias for `Reg`"] 9 | pub type NRXPD_CTRL = crate::Reg; 10 | #[doc = "WiFi RX control register"] 11 | pub mod nrxpd_ctrl; 12 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: rust 2 | rust: 3 | - nightly 4 | cache: cargo 5 | dist: "trusty" 6 | before_install: 7 | - python --version 8 | - pyenv install 3.6.3 9 | - pyenv global 3.6.3 10 | 11 | matrix: 12 | fast_finish: true 13 | 14 | install: 15 | - rustup component add rustfmt 16 | - pip3 install --upgrade --user svdtools 17 | - cargo install form --force 18 | - cargo install --git https://github.com/rust-embedded/svd2rust svd2rust --force 19 | 20 | script: make clean patch generate form fmt -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | OUTPUT=esp32.svd 2 | BASE=esp32.base.svd 3 | 4 | all: clean patch generate form fmt build 5 | 6 | codegen: clean generate form fmt build 7 | 8 | clean: 9 | rm -rf src/ 10 | 11 | patch: 12 | rm -f svd/$(OUTPUT) 13 | svd patch svd/patches/esp32.yaml 14 | mv svd/$(BASE).patched svd/$(OUTPUT) 15 | 16 | generate: 17 | svd2rust --target xtensa-lx -i svd/$(OUTPUT) 18 | 19 | form: 20 | form -i lib.rs -o src/ 21 | rm lib.rs 22 | 23 | fmt: 24 | cargo fmt 25 | 26 | build: 27 | cargo clean 28 | cargo +esp build -Zbuild-std --target xtensa-esp32-none-elf 29 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "esp32" 3 | version = "0.11.0" 4 | authors = ["Scott Mabin ", "Arjan Mels "] 5 | edition = "2018" 6 | readme = "README.md" 7 | repository = "https://github.com/esp-rs/esp32" 8 | description = "Peripheral access crate for the ESP32" 9 | keywords = ["no-std", "esp32", "wifi", "embedded"] 10 | categories = [ 11 | "embedded", 12 | "hardware-support", 13 | "no-std", 14 | ] 15 | include = [ 16 | "/src/**", 17 | "svd/esp32.svd", 18 | "build.rs", 19 | "device.x" 20 | ] 21 | license = "MIT OR Apache-2.0" 22 | 23 | [dependencies] 24 | bare-metal = "1.0" 25 | vcell = "0.1" 26 | xtensa-lx = "0.4.0" 27 | xtensa-lx-rt = { version = "0.7.0", optional = true } 28 | 29 | [features] 30 | default=["xtensa-lx/lx6"] 31 | rt=["xtensa-lx-rt/lx6"] 32 | -------------------------------------------------------------------------------- /src/flash_encryption.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | #[doc = "0x00..0x20 - "] 5 | pub buffer_: [crate::Reg; 8], 6 | #[doc = "0x20 - "] 7 | pub start: crate::Reg, 8 | #[doc = "0x24 - "] 9 | pub address: crate::Reg, 10 | #[doc = "0x28 - "] 11 | pub done: crate::Reg, 12 | } 13 | #[doc = "BUFFER_ register accessor: an alias for `Reg`"] 14 | pub type BUFFER_ = crate::Reg; 15 | #[doc = ""] 16 | pub mod buffer_; 17 | #[doc = "START register accessor: an alias for `Reg`"] 18 | pub type START = crate::Reg; 19 | #[doc = ""] 20 | pub mod start; 21 | #[doc = "ADDRESS register accessor: an alias for `Reg`"] 22 | pub type ADDRESS = crate::Reg; 23 | #[doc = ""] 24 | pub mod address; 25 | #[doc = "DONE register accessor: an alias for `Reg`"] 26 | pub type DONE = crate::Reg; 27 | #[doc = ""] 28 | pub mod done; 29 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Copyright (c) 2020 The esp-rs Project Developers 2 | 3 | Permission is hereby granted, free of charge, to any 4 | person obtaining a copy of this software and associated 5 | documentation files (the "Software"), to deal in the 6 | Software without restriction, including without 7 | limitation the rights to use, copy, modify, merge, 8 | publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software 10 | is furnished to do so, subject to the following 11 | conditions: 12 | 13 | The above copyright notice and this permission notice 14 | shall be included in all copies or substantial portions 15 | of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 18 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 19 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 20 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 21 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 22 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 24 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 | DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /src/frc_timer.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | #[doc = "0x00 - "] 5 | pub timer_load: crate::Reg, 6 | #[doc = "0x04 - "] 7 | pub timer_count: crate::Reg, 8 | #[doc = "0x08 - "] 9 | pub timer_ctrl: crate::Reg, 10 | #[doc = "0x0c - "] 11 | pub timer_int: crate::Reg, 12 | #[doc = "0x10 - "] 13 | pub timer_alarm: crate::Reg, 14 | } 15 | #[doc = "TIMER_LOAD register accessor: an alias for `Reg`"] 16 | pub type TIMER_LOAD = crate::Reg; 17 | #[doc = ""] 18 | pub mod timer_load; 19 | #[doc = "TIMER_COUNT register accessor: an alias for `Reg`"] 20 | pub type TIMER_COUNT = crate::Reg; 21 | #[doc = ""] 22 | pub mod timer_count; 23 | #[doc = "TIMER_CTRL register accessor: an alias for `Reg`"] 24 | pub type TIMER_CTRL = crate::Reg; 25 | #[doc = ""] 26 | pub mod timer_ctrl; 27 | #[doc = "TIMER_INT register accessor: an alias for `Reg`"] 28 | pub type TIMER_INT = crate::Reg; 29 | #[doc = ""] 30 | pub mod timer_int; 31 | #[doc = "TIMER_ALARM register accessor: an alias for `Reg`"] 32 | pub type TIMER_ALARM = crate::Reg; 33 | #[doc = ""] 34 | pub mod timer_alarm; 35 | -------------------------------------------------------------------------------- /src/aes.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | #[doc = "0x00 - "] 5 | pub start: crate::Reg, 6 | #[doc = "0x04 - "] 7 | pub idle: crate::Reg, 8 | #[doc = "0x08 - "] 9 | pub mode: crate::Reg, 10 | _reserved3: [u8; 0x04], 11 | #[doc = "0x10..0x30 - "] 12 | pub key_: [crate::Reg; 8], 13 | #[doc = "0x30..0x40 - "] 14 | pub text_: [crate::Reg; 4], 15 | #[doc = "0x40 - "] 16 | pub endian: crate::Reg, 17 | } 18 | #[doc = "START register accessor: an alias for `Reg`"] 19 | pub type START = crate::Reg; 20 | #[doc = ""] 21 | pub mod start; 22 | #[doc = "IDLE register accessor: an alias for `Reg`"] 23 | pub type IDLE = crate::Reg; 24 | #[doc = ""] 25 | pub mod idle; 26 | #[doc = "MODE register accessor: an alias for `Reg`"] 27 | pub type MODE = crate::Reg; 28 | #[doc = ""] 29 | pub mod mode; 30 | #[doc = "KEY_ register accessor: an alias for `Reg`"] 31 | pub type KEY_ = crate::Reg; 32 | #[doc = ""] 33 | pub mod key_; 34 | #[doc = "TEXT_ register accessor: an alias for `Reg`"] 35 | pub type TEXT_ = crate::Reg; 36 | #[doc = ""] 37 | pub mod text_; 38 | #[doc = "ENDIAN register accessor: an alias for `Reg`"] 39 | pub type ENDIAN = crate::Reg; 40 | #[doc = ""] 41 | pub mod endian; 42 | -------------------------------------------------------------------------------- /src/gpio/in_.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `IN` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DATA` reader - GPIO0~31 input value"] 17 | pub struct DATA_R(crate::FieldReader); 18 | impl DATA_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | DATA_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DATA_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - GPIO0~31 input value"] 33 | #[inline(always)] 34 | pub fn data(&self) -> DATA_R { 35 | DATA_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [in_](index.html) module"] 39 | pub struct IN_SPEC; 40 | impl crate::RegisterSpec for IN_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [in_::R](R) reader structure"] 44 | impl crate::Readable for IN_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets IN to value 0"] 48 | impl crate::Resettable for IN_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/in1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `IN1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DATA` reader - GPIO32~39 input value"] 17 | pub struct DATA_R(crate::FieldReader); 18 | impl DATA_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | DATA_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DATA_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:7 - GPIO32~39 input value"] 33 | #[inline(always)] 34 | pub fn data(&self) -> DATA_R { 35 | DATA_R::new((self.bits & 0xff) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [in1](index.html) module"] 39 | pub struct IN1_SPEC; 40 | impl crate::RegisterSpec for IN1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [in1::R](R) reader structure"] 44 | impl crate::Readable for IN1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets IN1 to value 0"] 48 | impl crate::Resettable for IN1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DEBUG` reader - "] 17 | pub struct DEBUG_R(crate::FieldReader); 18 | impl DEBUG_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | DEBUG_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DEBUG_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn debug(&self) -> DEBUG_R { 35 | DEBUG_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [status](index.html) module"] 39 | pub struct STATUS_SPEC; 40 | impl crate::RegisterSpec for STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [status::R](R) reader structure"] 44 | impl crate::Readable for STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets STATUS to value 0"] 48 | impl crate::Resettable for STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/uhci0/state0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `STATE0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `STATE0` reader - "] 17 | pub struct STATE0_R(crate::FieldReader); 18 | impl STATE0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | STATE0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for STATE0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn state0(&self) -> STATE0_R { 35 | STATE0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [state0](index.html) module"] 39 | pub struct STATE0_SPEC; 40 | impl crate::RegisterSpec for STATE0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [state0::R](R) reader structure"] 44 | impl crate::Readable for STATE0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets STATE0 to value 0"] 48 | impl crate::Resettable for STATE0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/uhci0/state1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `STATE1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `STATE1` reader - "] 17 | pub struct STATE1_R(crate::FieldReader); 18 | impl STATE1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | STATE1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for STATE1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn state1(&self) -> STATE1_R { 35 | STATE1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [state1](index.html) module"] 39 | pub struct STATE1_SPEC; 40 | impl crate::RegisterSpec for STATE1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [state1::R](R) reader structure"] 44 | impl crate::Readable for STATE1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets STATE1 to value 0"] 48 | impl crate::Resettable for STATE1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rtcio/in_.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `IN` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `NEXT` reader - GPIO0~17 input value"] 17 | pub struct NEXT_R(crate::FieldReader); 18 | impl NEXT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | NEXT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for NEXT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 14:31 - GPIO0~17 input value"] 33 | #[inline(always)] 34 | pub fn next(&self) -> NEXT_R { 35 | NEXT_R::new(((self.bits >> 14) & 0x0003_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [in_](index.html) module"] 39 | pub struct IN_SPEC; 40 | impl crate::RegisterSpec for IN_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [in_::R](R) reader structure"] 44 | impl crate::Readable for IN_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets IN to value 0"] 48 | impl crate::Resettable for IN_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/lacthi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `LACTHI` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `LACT_HI` reader - "] 17 | pub struct LACT_HI_R(crate::FieldReader); 18 | impl LACT_HI_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | LACT_HI_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for LACT_HI_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn lact_hi(&self) -> LACT_HI_R { 35 | LACT_HI_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [lacthi](index.html) module"] 39 | pub struct LACTHI_SPEC; 40 | impl crate::RegisterSpec for LACTHI_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [lacthi::R](R) reader structure"] 44 | impl crate::Readable for LACTHI_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets LACTHI to value 0"] 48 | impl crate::Resettable for LACTHI_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/lactlo.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `LACTLO` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `LACT_LO` reader - "] 17 | pub struct LACT_LO_R(crate::FieldReader); 18 | impl LACT_LO_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | LACT_LO_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for LACT_LO_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn lact_lo(&self) -> LACT_LO_R { 35 | LACT_LO_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [lactlo](index.html) module"] 39 | pub struct LACTLO_SPEC; 40 | impl crate::RegisterSpec for LACTLO_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [lactlo::R](R) reader structure"] 44 | impl crate::Readable for LACTLO_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets LACTLO to value 0"] 48 | impl crate::Resettable for LACTLO_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/spi0/ext2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `EXT2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `ST` reader - The status of spi state machine ."] 17 | pub struct ST_R(crate::FieldReader); 18 | impl ST_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | ST_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for ST_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:2 - The status of spi state machine ."] 33 | #[inline(always)] 34 | pub fn st(&self) -> ST_R { 35 | ST_R::new((self.bits & 0x07) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ext2](index.html) module"] 39 | pub struct EXT2_SPEC; 40 | impl crate::RegisterSpec for EXT2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ext2::R](R) reader structure"] 44 | impl crate::Readable for EXT2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets EXT2 to value 0"] 48 | impl crate::Resettable for EXT2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/spi0/date.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DATE` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DATE` reader - SPI register version."] 17 | pub struct DATE_R(crate::FieldReader); 18 | impl DATE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | DATE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DATE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:27 - SPI register version."] 33 | #[inline(always)] 34 | pub fn date(&self) -> DATE_R { 35 | DATE_R::new((self.bits & 0x0fff_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [date](index.html) module"] 39 | pub struct DATE_SPEC; 40 | impl crate::RegisterSpec for DATE_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [date::R](R) reader structure"] 44 | impl crate::Readable for DATE_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DATE to value 0x0160_4270"] 48 | impl crate::Resettable for DATE_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0x0160_4270 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pwm0/cap_ch0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CAP_CH0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CAP0_VALUE` reader - "] 17 | pub struct CAP0_VALUE_R(crate::FieldReader); 18 | impl CAP0_VALUE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CAP0_VALUE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CAP0_VALUE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn cap0_value(&self) -> CAP0_VALUE_R { 35 | CAP0_VALUE_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cap_ch0](index.html) module"] 39 | pub struct CAP_CH0_SPEC; 40 | impl crate::RegisterSpec for CAP_CH0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cap_ch0::R](R) reader structure"] 44 | impl crate::Readable for CAP_CH0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CAP_CH0 to value 0"] 48 | impl crate::Resettable for CAP_CH0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pwm0/cap_ch1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CAP_CH1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CAP1_VALUE` reader - "] 17 | pub struct CAP1_VALUE_R(crate::FieldReader); 18 | impl CAP1_VALUE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CAP1_VALUE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CAP1_VALUE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn cap1_value(&self) -> CAP1_VALUE_R { 35 | CAP1_VALUE_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cap_ch1](index.html) module"] 39 | pub struct CAP_CH1_SPEC; 40 | impl crate::RegisterSpec for CAP_CH1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cap_ch1::R](R) reader structure"] 44 | impl crate::Readable for CAP_CH1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CAP_CH1 to value 0"] 48 | impl crate::Resettable for CAP_CH1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pwm0/cap_ch2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CAP_CH2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CAP2_VALUE` reader - "] 17 | pub struct CAP2_VALUE_R(crate::FieldReader); 18 | impl CAP2_VALUE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CAP2_VALUE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CAP2_VALUE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn cap2_value(&self) -> CAP2_VALUE_R { 35 | CAP2_VALUE_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cap_ch2](index.html) module"] 39 | pub struct CAP_CH2_SPEC; 40 | impl crate::RegisterSpec for CAP_CH2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cap_ch2::R](R) reader structure"] 44 | impl crate::Readable for CAP_CH2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CAP_CH2 to value 0"] 48 | impl crate::Resettable for CAP_CH2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rtc_cntl/time0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `TIME0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `TIME_LO` reader - RTC timer low 32 bits"] 17 | pub struct TIME_LO_R(crate::FieldReader); 18 | impl TIME_LO_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | TIME_LO_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for TIME_LO_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - RTC timer low 32 bits"] 33 | #[inline(always)] 34 | pub fn time_lo(&self) -> TIME_LO_R { 35 | TIME_LO_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [time0](index.html) module"] 39 | pub struct TIME0_SPEC; 40 | impl crate::RegisterSpec for TIME0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [time0::R](R) reader structure"] 44 | impl crate::Readable for TIME0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets TIME0 to value 0"] 48 | impl crate::Resettable for TIME0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rtc_cntl/time1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `TIME1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `TIME_HI` reader - RTC timer high 16 bits"] 17 | pub struct TIME_HI_R(crate::FieldReader); 18 | impl TIME_HI_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | TIME_HI_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for TIME_HI_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - RTC timer high 16 bits"] 33 | #[inline(always)] 34 | pub fn time_hi(&self) -> TIME_HI_R { 35 | TIME_HI_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [time1](index.html) module"] 39 | pub struct TIME1_SPEC; 40 | impl crate::RegisterSpec for TIME1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [time1::R](R) reader structure"] 44 | impl crate::Readable for TIME1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets TIME1 to value 0"] 48 | impl crate::Resettable for TIME1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /device.x: -------------------------------------------------------------------------------- 1 | PROVIDE(UHCI0 = DefaultHandler); 2 | PROVIDE(TG0_T0_LEVEL = DefaultHandler); 3 | PROVIDE(TG0_T1_LEVEL = DefaultHandler); 4 | PROVIDE(TG0_WDT_LEVEL = DefaultHandler); 5 | PROVIDE(TG0_LACT_LEVEL = DefaultHandler); 6 | PROVIDE(TG1_T0_LEVEL = DefaultHandler); 7 | PROVIDE(TG1_T1_LEVEL = DefaultHandler); 8 | PROVIDE(TG1_WDT_LEVEL = DefaultHandler); 9 | PROVIDE(TG1_LACT_LEVEL = DefaultHandler); 10 | PROVIDE(GPIO = DefaultHandler); 11 | PROVIDE(GPIO_NMI = DefaultHandler); 12 | PROVIDE(SPI0 = DefaultHandler); 13 | PROVIDE(SPI1 = DefaultHandler); 14 | PROVIDE(SPI2 = DefaultHandler); 15 | PROVIDE(SPI3 = DefaultHandler); 16 | PROVIDE(I2S0 = DefaultHandler); 17 | PROVIDE(I2S1 = DefaultHandler); 18 | PROVIDE(UART0 = DefaultHandler); 19 | PROVIDE(UART1 = DefaultHandler); 20 | PROVIDE(UART2 = DefaultHandler); 21 | PROVIDE(PWM0 = DefaultHandler); 22 | PROVIDE(PWM1 = DefaultHandler); 23 | PROVIDE(PWM2 = DefaultHandler); 24 | PROVIDE(PWM3 = DefaultHandler); 25 | PROVIDE(LEDC = DefaultHandler); 26 | PROVIDE(EFUSE = DefaultHandler); 27 | PROVIDE(RTC_CORE = DefaultHandler); 28 | PROVIDE(RMT = DefaultHandler); 29 | PROVIDE(PCNT = DefaultHandler); 30 | PROVIDE(I2C_EXT0 = DefaultHandler); 31 | PROVIDE(I2C_EXT1 = DefaultHandler); 32 | PROVIDE(RSA = DefaultHandler); 33 | PROVIDE(SPI1_DMA = DefaultHandler); 34 | PROVIDE(SPI2_DMA = DefaultHandler); 35 | PROVIDE(SPI3_DMA = DefaultHandler); 36 | PROVIDE(TIMER1 = DefaultHandler); 37 | PROVIDE(TIMER2 = DefaultHandler); 38 | PROVIDE(TG0_T0_EDGE = DefaultHandler); 39 | PROVIDE(TG0_T1_EDGE = DefaultHandler); 40 | PROVIDE(TG0_WDT_EDGE = DefaultHandler); 41 | PROVIDE(TG0_LACT_EDGE = DefaultHandler); 42 | PROVIDE(TG1_T0_EDGE = DefaultHandler); 43 | PROVIDE(TG1_T1_EDGE = DefaultHandler); 44 | PROVIDE(TG1_WDT_EDGE = DefaultHandler); 45 | PROVIDE(TG1_LACT_EDGE = DefaultHandler); 46 | 47 | -------------------------------------------------------------------------------- /src/i2s0/lc_state0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `LC_STATE0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `LC_STATE0` reader - "] 17 | pub struct LC_STATE0_R(crate::FieldReader); 18 | impl LC_STATE0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | LC_STATE0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for LC_STATE0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn lc_state0(&self) -> LC_STATE0_R { 35 | LC_STATE0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [lc_state0](index.html) module"] 39 | pub struct LC_STATE0_SPEC; 40 | impl crate::RegisterSpec for LC_STATE0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [lc_state0::R](R) reader structure"] 44 | impl crate::Readable for LC_STATE0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets LC_STATE0 to value 0"] 48 | impl crate::Resettable for LC_STATE0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/lc_state1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `LC_STATE1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `LC_STATE1` reader - "] 17 | pub struct LC_STATE1_R(crate::FieldReader); 18 | impl LC_STATE1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | LC_STATE1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for LC_STATE1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn lc_state1(&self) -> LC_STATE1_R { 35 | LC_STATE1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [lc_state1](index.html) module"] 39 | pub struct LC_STATE1_SPEC; 40 | impl crate::RegisterSpec for LC_STATE1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [lc_state1::R](R) reader structure"] 44 | impl crate::Readable for LC_STATE1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets LC_STATE1 to value 0"] 48 | impl crate::Resettable for LC_STATE1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rtc_cntl/diag1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DIAG1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `LOW_POWER_DIAG1` reader - "] 17 | pub struct LOW_POWER_DIAG1_R(crate::FieldReader); 18 | impl LOW_POWER_DIAG1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | LOW_POWER_DIAG1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for LOW_POWER_DIAG1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn low_power_diag1(&self) -> LOW_POWER_DIAG1_R { 35 | LOW_POWER_DIAG1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [diag1](index.html) module"] 39 | pub struct DIAG1_SPEC; 40 | impl crate::RegisterSpec for DIAG1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [diag1::R](R) reader structure"] 44 | impl crate::Readable for DIAG1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DIAG1 to value 0"] 48 | impl crate::Resettable for DIAG1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_0_length.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_0_LENGTH` reader"] 2 | pub struct R(crate::R<_0_LENGTH_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_0_LENGTH_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_0_LENGTH_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC0_LEN` reader - "] 17 | pub struct SLC0_LEN_R(crate::FieldReader); 18 | impl SLC0_LEN_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC0_LEN_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC0_LEN_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:19"] 33 | #[inline(always)] 34 | pub fn slc0_len(&self) -> SLC0_LEN_R { 35 | SLC0_LEN_R::new((self.bits & 0x000f_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_0_length](index.html) module"] 39 | pub struct _0_LENGTH_SPEC; 40 | impl crate::RegisterSpec for _0_LENGTH_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_0_length::R](R) reader structure"] 44 | impl crate::Readable for _0_LENGTH_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _0_LENGTH to value 0"] 48 | impl crate::Resettable for _0_LENGTH_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_0_state0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_0_STATE0` reader"] 2 | pub struct R(crate::R<_0_STATE0_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_0_STATE0_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_0_STATE0_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC0_STATE0` reader - "] 17 | pub struct SLC0_STATE0_R(crate::FieldReader); 18 | impl SLC0_STATE0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC0_STATE0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC0_STATE0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc0_state0(&self) -> SLC0_STATE0_R { 35 | SLC0_STATE0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_0_state0](index.html) module"] 39 | pub struct _0_STATE0_SPEC; 40 | impl crate::RegisterSpec for _0_STATE0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_0_state0::R](R) reader structure"] 44 | impl crate::Readable for _0_STATE0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _0_STATE0 to value 0"] 48 | impl crate::Resettable for _0_STATE0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_0_state1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_0_STATE1` reader"] 2 | pub struct R(crate::R<_0_STATE1_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_0_STATE1_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_0_STATE1_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC0_STATE1` reader - "] 17 | pub struct SLC0_STATE1_R(crate::FieldReader); 18 | impl SLC0_STATE1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC0_STATE1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC0_STATE1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc0_state1(&self) -> SLC0_STATE1_R { 35 | SLC0_STATE1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_0_state1](index.html) module"] 39 | pub struct _0_STATE1_SPEC; 40 | impl crate::RegisterSpec for _0_STATE1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_0_state1::R](R) reader structure"] 44 | impl crate::Readable for _0_STATE1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _0_STATE1 to value 0"] 48 | impl crate::Resettable for _0_STATE1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_1_state0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_1_STATE0` reader"] 2 | pub struct R(crate::R<_1_STATE0_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_1_STATE0_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_1_STATE0_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC1_STATE0` reader - "] 17 | pub struct SLC1_STATE0_R(crate::FieldReader); 18 | impl SLC1_STATE0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC1_STATE0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC1_STATE0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc1_state0(&self) -> SLC1_STATE0_R { 35 | SLC1_STATE0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_1_state0](index.html) module"] 39 | pub struct _1_STATE0_SPEC; 40 | impl crate::RegisterSpec for _1_STATE0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_1_state0::R](R) reader structure"] 44 | impl crate::Readable for _1_STATE0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _1_STATE0 to value 0"] 48 | impl crate::Resettable for _1_STATE0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_1_state1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_1_STATE1` reader"] 2 | pub struct R(crate::R<_1_STATE1_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_1_STATE1_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_1_STATE1_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC1_STATE1` reader - "] 17 | pub struct SLC1_STATE1_R(crate::FieldReader); 18 | impl SLC1_STATE1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC1_STATE1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC1_STATE1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc1_state1(&self) -> SLC1_STATE1_R { 35 | SLC1_STATE1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_1_state1](index.html) module"] 39 | pub struct _1_STATE1_SPEC; 40 | impl crate::RegisterSpec for _1_STATE1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_1_state1::R](R) reader structure"] 44 | impl crate::Readable for _1_STATE1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _1_STATE1 to value 0"] 48 | impl crate::Resettable for _1_STATE1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/resp0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RESP0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RESPONSE0` reader - Bit\\[31:0\\] 17 | of response."] 18 | pub struct RESPONSE0_R(crate::FieldReader); 19 | impl RESPONSE0_R { 20 | #[inline(always)] 21 | pub(crate) fn new(bits: u32) -> Self { 22 | RESPONSE0_R(crate::FieldReader::new(bits)) 23 | } 24 | } 25 | impl core::ops::Deref for RESPONSE0_R { 26 | type Target = crate::FieldReader; 27 | #[inline(always)] 28 | fn deref(&self) -> &Self::Target { 29 | &self.0 30 | } 31 | } 32 | impl R { 33 | #[doc = "Bits 0:31 - Bit\\[31:0\\] 34 | of response."] 35 | #[inline(always)] 36 | pub fn response0(&self) -> RESPONSE0_R { 37 | RESPONSE0_R::new(self.bits as u32) 38 | } 39 | } 40 | #[doc = "Response data register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [resp0](index.html) module"] 41 | pub struct RESP0_SPEC; 42 | impl crate::RegisterSpec for RESP0_SPEC { 43 | type Ux = u32; 44 | } 45 | #[doc = "`read()` method returns [resp0::R](R) reader structure"] 46 | impl crate::Readable for RESP0_SPEC { 47 | type Reader = R; 48 | } 49 | #[doc = "`reset()` method sets RESP0 to value 0"] 50 | impl crate::Resettable for RESP0_SPEC { 51 | #[inline(always)] 52 | fn reset_value() -> Self::Ux { 53 | 0 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/slc/cmd_infor0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CMD_INFOR0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CMD_CONTENT0` reader - "] 17 | pub struct CMD_CONTENT0_R(crate::FieldReader); 18 | impl CMD_CONTENT0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CMD_CONTENT0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CMD_CONTENT0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn cmd_content0(&self) -> CMD_CONTENT0_R { 35 | CMD_CONTENT0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cmd_infor0](index.html) module"] 39 | pub struct CMD_INFOR0_SPEC; 40 | impl crate::RegisterSpec for CMD_INFOR0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cmd_infor0::R](R) reader structure"] 44 | impl crate::Readable for CMD_INFOR0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CMD_INFOR0 to value 0"] 48 | impl crate::Resettable for CMD_INFOR0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/cmd_infor1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CMD_INFOR1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CMD_CONTENT1` reader - "] 17 | pub struct CMD_CONTENT1_R(crate::FieldReader); 18 | impl CMD_CONTENT1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CMD_CONTENT1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CMD_CONTENT1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn cmd_content1(&self) -> CMD_CONTENT1_R { 35 | CMD_CONTENT1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cmd_infor1](index.html) module"] 39 | pub struct CMD_INFOR1_SPEC; 40 | impl crate::RegisterSpec for CMD_INFOR1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cmd_infor1::R](R) reader structure"] 44 | impl crate::Readable for CMD_INFOR1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CMD_INFOR1 to value 0"] 48 | impl crate::Resettable for CMD_INFOR1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/inlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `INLINK_DSCR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `INLINK_DSCR` reader - "] 17 | pub struct INLINK_DSCR_R(crate::FieldReader); 18 | impl INLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | INLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for INLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn inlink_dscr(&self) -> INLINK_DSCR_R { 35 | INLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [inlink_dscr](index.html) module"] 39 | pub struct INLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for INLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [inlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for INLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets INLINK_DSCR to value 0"] 48 | impl crate::Resettable for INLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u1_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U1_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U1` reader - "] 17 | pub struct CORE_STATUS_U1_R(crate::FieldReader); 18 | impl CORE_STATUS_U1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u1(&self) -> CORE_STATUS_U1_R { 35 | CORE_STATUS_U1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u1_status](index.html) module"] 39 | pub struct U1_STATUS_SPEC; 40 | impl crate::RegisterSpec for U1_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u1_status::R](R) reader structure"] 44 | impl crate::Readable for U1_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U1_STATUS to value 0"] 48 | impl crate::Resettable for U1_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u2_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U2_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U2` reader - "] 17 | pub struct CORE_STATUS_U2_R(crate::FieldReader); 18 | impl CORE_STATUS_U2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u2(&self) -> CORE_STATUS_U2_R { 35 | CORE_STATUS_U2_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u2_status](index.html) module"] 39 | pub struct U2_STATUS_SPEC; 40 | impl crate::RegisterSpec for U2_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u2_status::R](R) reader structure"] 44 | impl crate::Readable for U2_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U2_STATUS to value 0"] 48 | impl crate::Resettable for U2_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u3_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U3_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U3` reader - "] 17 | pub struct CORE_STATUS_U3_R(crate::FieldReader); 18 | impl CORE_STATUS_U3_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U3_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U3_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u3(&self) -> CORE_STATUS_U3_R { 35 | CORE_STATUS_U3_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u3_status](index.html) module"] 39 | pub struct U3_STATUS_SPEC; 40 | impl crate::RegisterSpec for U3_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u3_status::R](R) reader structure"] 44 | impl crate::Readable for U3_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U3_STATUS to value 0"] 48 | impl crate::Resettable for U3_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u4_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U4_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U4` reader - "] 17 | pub struct CORE_STATUS_U4_R(crate::FieldReader); 18 | impl CORE_STATUS_U4_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U4_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U4_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u4(&self) -> CORE_STATUS_U4_R { 35 | CORE_STATUS_U4_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u4_status](index.html) module"] 39 | pub struct U4_STATUS_SPEC; 40 | impl crate::RegisterSpec for U4_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u4_status::R](R) reader structure"] 44 | impl crate::Readable for U4_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U4_STATUS to value 0"] 48 | impl crate::Resettable for U4_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u5_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U5_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U5` reader - "] 17 | pub struct CORE_STATUS_U5_R(crate::FieldReader); 18 | impl CORE_STATUS_U5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u5(&self) -> CORE_STATUS_U5_R { 35 | CORE_STATUS_U5_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u5_status](index.html) module"] 39 | pub struct U5_STATUS_SPEC; 40 | impl crate::RegisterSpec for U5_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u5_status::R](R) reader structure"] 44 | impl crate::Readable for U5_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U5_STATUS to value 0"] 48 | impl crate::Resettable for U5_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u6_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U6_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U6` reader - "] 17 | pub struct CORE_STATUS_U6_R(crate::FieldReader); 18 | impl CORE_STATUS_U6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u6(&self) -> CORE_STATUS_U6_R { 35 | CORE_STATUS_U6_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u6_status](index.html) module"] 39 | pub struct U6_STATUS_SPEC; 40 | impl crate::RegisterSpec for U6_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u6_status::R](R) reader structure"] 44 | impl crate::Readable for U6_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U6_STATUS to value 0"] 48 | impl crate::Resettable for U6_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u7_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U7_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CORE_STATUS_U7` reader - "] 17 | pub struct CORE_STATUS_U7_R(crate::FieldReader); 18 | impl CORE_STATUS_U7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | CORE_STATUS_U7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CORE_STATUS_U7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn core_status_u7(&self) -> CORE_STATUS_U7_R { 35 | CORE_STATUS_U7_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u7_status](index.html) module"] 39 | pub struct U7_STATUS_SPEC; 40 | impl crate::RegisterSpec for U7_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u7_status::R](R) reader structure"] 44 | impl crate::Readable for U7_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U7_STATUS to value 0"] 48 | impl crate::Resettable for U7_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/resp1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RESP1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RESPONSE1` reader - Bit\\[63:32\\] 17 | of long response."] 18 | pub struct RESPONSE1_R(crate::FieldReader); 19 | impl RESPONSE1_R { 20 | #[inline(always)] 21 | pub(crate) fn new(bits: u32) -> Self { 22 | RESPONSE1_R(crate::FieldReader::new(bits)) 23 | } 24 | } 25 | impl core::ops::Deref for RESPONSE1_R { 26 | type Target = crate::FieldReader; 27 | #[inline(always)] 28 | fn deref(&self) -> &Self::Target { 29 | &self.0 30 | } 31 | } 32 | impl R { 33 | #[doc = "Bits 0:31 - Bit\\[63:32\\] 34 | of long response."] 35 | #[inline(always)] 36 | pub fn response1(&self) -> RESPONSE1_R { 37 | RESPONSE1_R::new(self.bits as u32) 38 | } 39 | } 40 | #[doc = "Long response data register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [resp1](index.html) module"] 41 | pub struct RESP1_SPEC; 42 | impl crate::RegisterSpec for RESP1_SPEC { 43 | type Ux = u32; 44 | } 45 | #[doc = "`read()` method returns [resp1::R](R) reader structure"] 46 | impl crate::Readable for RESP1_SPEC { 47 | type Reader = R; 48 | } 49 | #[doc = "`reset()` method sets RESP1 to value 0"] 50 | impl crate::Resettable for RESP1_SPEC { 51 | #[inline(always)] 52 | fn reset_value() -> Self::Ux { 53 | 0 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/sdmmc/resp2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RESP2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RESPONSE2` reader - Bit\\[95:64\\] 17 | of long response."] 18 | pub struct RESPONSE2_R(crate::FieldReader); 19 | impl RESPONSE2_R { 20 | #[inline(always)] 21 | pub(crate) fn new(bits: u32) -> Self { 22 | RESPONSE2_R(crate::FieldReader::new(bits)) 23 | } 24 | } 25 | impl core::ops::Deref for RESPONSE2_R { 26 | type Target = crate::FieldReader; 27 | #[inline(always)] 28 | fn deref(&self) -> &Self::Target { 29 | &self.0 30 | } 31 | } 32 | impl R { 33 | #[doc = "Bits 0:31 - Bit\\[95:64\\] 34 | of long response."] 35 | #[inline(always)] 36 | pub fn response2(&self) -> RESPONSE2_R { 37 | RESPONSE2_R::new(self.bits as u32) 38 | } 39 | } 40 | #[doc = "Long response data register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [resp2](index.html) module"] 41 | pub struct RESP2_SPEC; 42 | impl crate::RegisterSpec for RESP2_SPEC { 43 | type Ux = u32; 44 | } 45 | #[doc = "`read()` method returns [resp2::R](R) reader structure"] 46 | impl crate::Readable for RESP2_SPEC { 47 | type Reader = R; 48 | } 49 | #[doc = "`reset()` method sets RESP2 to value 0"] 50 | impl crate::Resettable for RESP2_SPEC { 51 | #[inline(always)] 52 | fn reset_value() -> Self::Ux { 53 | 0 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/timg0/t0hi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `T0HI` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `T0_HI` reader - Register to store timer 0 time-base counter current value higher 32 bits."] 17 | pub struct T0_HI_R(crate::FieldReader); 18 | impl T0_HI_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | T0_HI_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for T0_HI_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Register to store timer 0 time-base counter current value higher 32 bits."] 33 | #[inline(always)] 34 | pub fn t0_hi(&self) -> T0_HI_R { 35 | T0_HI_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t0hi](index.html) module"] 39 | pub struct T0HI_SPEC; 40 | impl crate::RegisterSpec for T0HI_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [t0hi::R](R) reader structure"] 44 | impl crate::Readable for T0HI_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets T0HI to value 0"] 48 | impl crate::Resettable for T0HI_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/t0lo.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `T0LO` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `T0_LO` reader - Register to store timer 0 time-base counter current value lower 32 bits."] 17 | pub struct T0_LO_R(crate::FieldReader); 18 | impl T0_LO_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | T0_LO_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for T0_LO_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Register to store timer 0 time-base counter current value lower 32 bits."] 33 | #[inline(always)] 34 | pub fn t0_lo(&self) -> T0_LO_R { 35 | T0_LO_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t0lo](index.html) module"] 39 | pub struct T0LO_SPEC; 40 | impl crate::RegisterSpec for T0LO_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [t0lo::R](R) reader structure"] 44 | impl crate::Readable for T0LO_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets T0LO to value 0"] 48 | impl crate::Resettable for T0LO_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/t1hi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `T1HI` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `T1_HI` reader - Register to store timer 1 time-base counter current value higher 32 bits."] 17 | pub struct T1_HI_R(crate::FieldReader); 18 | impl T1_HI_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | T1_HI_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for T1_HI_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Register to store timer 1 time-base counter current value higher 32 bits."] 33 | #[inline(always)] 34 | pub fn t1_hi(&self) -> T1_HI_R { 35 | T1_HI_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t1hi](index.html) module"] 39 | pub struct T1HI_SPEC; 40 | impl crate::RegisterSpec for T1HI_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [t1hi::R](R) reader structure"] 44 | impl crate::Readable for T1HI_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets T1HI to value 0"] 48 | impl crate::Resettable for T1HI_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/t1lo.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `T1LO` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `T1_LO` reader - Register to store timer 1 time-base counter current value lower 32 bits."] 17 | pub struct T1_LO_R(crate::FieldReader); 18 | impl T1_LO_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | T1_LO_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for T1_LO_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Register to store timer 1 time-base counter current value lower 32 bits."] 33 | #[inline(always)] 34 | pub fn t1_lo(&self) -> T1_LO_R { 35 | T1_LO_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t1lo](index.html) module"] 39 | pub struct T1LO_SPEC; 40 | impl crate::RegisterSpec for T1LO_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [t1lo::R](R) reader structure"] 44 | impl crate::Readable for T1LO_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets T1LO to value 0"] 48 | impl crate::Resettable for T1LO_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/strap.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `STRAP` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `STRAPPING` reader - {10'b0, MTDI, GPIO0, GPIO2, GPIO4, MTDO, GPIO5}"] 17 | pub struct STRAPPING_R(crate::FieldReader); 18 | impl STRAPPING_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | STRAPPING_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for STRAPPING_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - {10'b0, MTDI, GPIO0, GPIO2, GPIO4, MTDO, GPIO5}"] 33 | #[inline(always)] 34 | pub fn strapping(&self) -> STRAPPING_R { 35 | STRAPPING_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [strap](index.html) module"] 39 | pub struct STRAP_SPEC; 40 | impl crate::RegisterSpec for STRAP_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [strap::R](R) reader structure"] 44 | impl crate::Readable for STRAP_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets STRAP to value 0"] 48 | impl crate::Resettable for STRAP_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rsa/clean.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CLEAN` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `CLEAN` reader - This bit will read 1 once the memory initialization is completed."] 17 | pub struct CLEAN_R(crate::FieldReader); 18 | impl CLEAN_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: bool) -> Self { 21 | CLEAN_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for CLEAN_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bit 0 - This bit will read 1 once the memory initialization is completed."] 33 | #[inline(always)] 34 | pub fn clean(&self) -> CLEAN_R { 35 | CLEAN_R::new((self.bits & 0x01) != 0) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [clean](index.html) module"] 39 | pub struct CLEAN_SPEC; 40 | impl crate::RegisterSpec for CLEAN_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [clean::R](R) reader structure"] 44 | impl crate::Readable for CLEAN_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CLEAN to value 0"] 48 | impl crate::Resettable for CLEAN_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/resp3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RESP3` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RESPONSE3` reader - Bit\\[127:96\\] 17 | of long response."] 18 | pub struct RESPONSE3_R(crate::FieldReader); 19 | impl RESPONSE3_R { 20 | #[inline(always)] 21 | pub(crate) fn new(bits: u32) -> Self { 22 | RESPONSE3_R(crate::FieldReader::new(bits)) 23 | } 24 | } 25 | impl core::ops::Deref for RESPONSE3_R { 26 | type Target = crate::FieldReader; 27 | #[inline(always)] 28 | fn deref(&self) -> &Self::Target { 29 | &self.0 30 | } 31 | } 32 | impl R { 33 | #[doc = "Bits 0:31 - Bit\\[127:96\\] 34 | of long response."] 35 | #[inline(always)] 36 | pub fn response3(&self) -> RESPONSE3_R { 37 | RESPONSE3_R::new(self.bits as u32) 38 | } 39 | } 40 | #[doc = "Long response data register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [resp3](index.html) module"] 41 | pub struct RESP3_SPEC; 42 | impl crate::RegisterSpec for RESP3_SPEC { 43 | type Ux = u32; 44 | } 45 | #[doc = "`read()` method returns [resp3::R](R) reader structure"] 46 | impl crate::Readable for RESP3_SPEC { 47 | type Reader = R; 48 | } 49 | #[doc = "`reset()` method sets RESP3 to value 0"] 50 | impl crate::Resettable for RESP3_SPEC { 51 | #[inline(always)] 52 | fn reset_value() -> Self::Ux { 53 | 0 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/gpio/acpu_int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `ACPU_INT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APPCPU_INT` reader - GPIO0~31 APP CPU interrupt status"] 17 | pub struct APPCPU_INT_R(crate::FieldReader); 18 | impl APPCPU_INT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APPCPU_INT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APPCPU_INT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - GPIO0~31 APP CPU interrupt status"] 33 | #[inline(always)] 34 | pub fn appcpu_int(&self) -> APPCPU_INT_R { 35 | APPCPU_INT_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [acpu_int](index.html) module"] 39 | pub struct ACPU_INT_SPEC; 40 | impl crate::RegisterSpec for ACPU_INT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [acpu_int::R](R) reader structure"] 44 | impl crate::Readable for ACPU_INT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets ACPU_INT to value 0"] 48 | impl crate::Resettable for ACPU_INT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/pcpu_int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `PCPU_INT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PROCPU_INT` reader - GPIO0~31 PRO CPU interrupt status"] 17 | pub struct PROCPU_INT_R(crate::FieldReader); 18 | impl PROCPU_INT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | PROCPU_INT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PROCPU_INT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - GPIO0~31 PRO CPU interrupt status"] 33 | #[inline(always)] 34 | pub fn procpu_int(&self) -> PROCPU_INT_R { 35 | PROCPU_INT_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [pcpu_int](index.html) module"] 39 | pub struct PCPU_INT_SPEC; 40 | impl crate::RegisterSpec for PCPU_INT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [pcpu_int::R](R) reader structure"] 44 | impl crate::Readable for PCPU_INT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets PCPU_INT to value 0"] 48 | impl crate::Resettable for PCPU_INT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/outlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `OUTLINK_DSCR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `OUTLINK_DSCR` reader - "] 17 | pub struct OUTLINK_DSCR_R(crate::FieldReader); 18 | impl OUTLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | OUTLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for OUTLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn outlink_dscr(&self) -> OUTLINK_DSCR_R { 35 | OUTLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [outlink_dscr](index.html) module"] 39 | pub struct OUTLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for OUTLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [outlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for OUTLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets OUTLINK_DSCR to value 0"] 48 | impl crate::Resettable for OUTLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT0` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT0_R(crate::FieldReader); 18 | impl BLK1_DOUT0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout0(&self) -> BLK1_DOUT0_R { 35 | BLK1_DOUT0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata0](index.html) module"] 39 | pub struct BLK1_RDATA0_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata0::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA0 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT1` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT1_R(crate::FieldReader); 18 | impl BLK1_DOUT1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout1(&self) -> BLK1_DOUT1_R { 35 | BLK1_DOUT1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata1](index.html) module"] 39 | pub struct BLK1_RDATA1_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata1::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA1 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT2` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT2_R(crate::FieldReader); 18 | impl BLK1_DOUT2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout2(&self) -> BLK1_DOUT2_R { 35 | BLK1_DOUT2_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata2](index.html) module"] 39 | pub struct BLK1_RDATA2_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata2::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA2 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA3` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT3` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT3_R(crate::FieldReader); 18 | impl BLK1_DOUT3_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT3_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT3_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout3(&self) -> BLK1_DOUT3_R { 35 | BLK1_DOUT3_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata3](index.html) module"] 39 | pub struct BLK1_RDATA3_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA3_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata3::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA3_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA3 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA3_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA4` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT4` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT4_R(crate::FieldReader); 18 | impl BLK1_DOUT4_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT4_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT4_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout4(&self) -> BLK1_DOUT4_R { 35 | BLK1_DOUT4_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata4](index.html) module"] 39 | pub struct BLK1_RDATA4_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA4_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata4::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA4_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA4 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA4_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA5` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT5` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT5_R(crate::FieldReader); 18 | impl BLK1_DOUT5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout5(&self) -> BLK1_DOUT5_R { 35 | BLK1_DOUT5_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata5](index.html) module"] 39 | pub struct BLK1_RDATA5_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA5_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata5::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA5_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA5 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA5_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA6` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT6` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT6_R(crate::FieldReader); 18 | impl BLK1_DOUT6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout6(&self) -> BLK1_DOUT6_R { 35 | BLK1_DOUT6_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata6](index.html) module"] 39 | pub struct BLK1_RDATA6_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA6_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata6::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA6_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA6 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA6_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk1_rdata7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK1_RDATA7` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK1_DOUT7` reader - read for BLOCK1"] 17 | pub struct BLK1_DOUT7_R(crate::FieldReader); 18 | impl BLK1_DOUT7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK1_DOUT7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK1_DOUT7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK1"] 33 | #[inline(always)] 34 | pub fn blk1_dout7(&self) -> BLK1_DOUT7_R { 35 | BLK1_DOUT7_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk1_rdata7](index.html) module"] 39 | pub struct BLK1_RDATA7_SPEC; 40 | impl crate::RegisterSpec for BLK1_RDATA7_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk1_rdata7::R](R) reader structure"] 44 | impl crate::Readable for BLK1_RDATA7_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK1_RDATA7 to value 0"] 48 | impl crate::Resettable for BLK1_RDATA7_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT0` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT0_R(crate::FieldReader); 18 | impl BLK2_DOUT0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout0(&self) -> BLK2_DOUT0_R { 35 | BLK2_DOUT0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata0](index.html) module"] 39 | pub struct BLK2_RDATA0_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata0::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA0 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT1` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT1_R(crate::FieldReader); 18 | impl BLK2_DOUT1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout1(&self) -> BLK2_DOUT1_R { 35 | BLK2_DOUT1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata1](index.html) module"] 39 | pub struct BLK2_RDATA1_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata1::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA1 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT2` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT2_R(crate::FieldReader); 18 | impl BLK2_DOUT2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout2(&self) -> BLK2_DOUT2_R { 35 | BLK2_DOUT2_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata2](index.html) module"] 39 | pub struct BLK2_RDATA2_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata2::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA2 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA3` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT3` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT3_R(crate::FieldReader); 18 | impl BLK2_DOUT3_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT3_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT3_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout3(&self) -> BLK2_DOUT3_R { 35 | BLK2_DOUT3_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata3](index.html) module"] 39 | pub struct BLK2_RDATA3_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA3_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata3::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA3_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA3 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA3_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA4` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT4` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT4_R(crate::FieldReader); 18 | impl BLK2_DOUT4_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT4_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT4_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout4(&self) -> BLK2_DOUT4_R { 35 | BLK2_DOUT4_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata4](index.html) module"] 39 | pub struct BLK2_RDATA4_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA4_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata4::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA4_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA4 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA4_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA5` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT5` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT5_R(crate::FieldReader); 18 | impl BLK2_DOUT5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout5(&self) -> BLK2_DOUT5_R { 35 | BLK2_DOUT5_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata5](index.html) module"] 39 | pub struct BLK2_RDATA5_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA5_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata5::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA5_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA5 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA5_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA6` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT6` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT6_R(crate::FieldReader); 18 | impl BLK2_DOUT6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout6(&self) -> BLK2_DOUT6_R { 35 | BLK2_DOUT6_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata6](index.html) module"] 39 | pub struct BLK2_RDATA6_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA6_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata6::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA6_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA6 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA6_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk2_rdata7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK2_RDATA7` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK2_DOUT7` reader - read for BLOCK2"] 17 | pub struct BLK2_DOUT7_R(crate::FieldReader); 18 | impl BLK2_DOUT7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK2_DOUT7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK2_DOUT7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK2"] 33 | #[inline(always)] 34 | pub fn blk2_dout7(&self) -> BLK2_DOUT7_R { 35 | BLK2_DOUT7_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk2_rdata7](index.html) module"] 39 | pub struct BLK2_RDATA7_SPEC; 40 | impl crate::RegisterSpec for BLK2_RDATA7_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk2_rdata7::R](R) reader structure"] 44 | impl crate::Readable for BLK2_RDATA7_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK2_RDATA7 to value 0"] 48 | impl crate::Resettable for BLK2_RDATA7_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT0` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT0_R(crate::FieldReader); 18 | impl BLK3_DOUT0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout0(&self) -> BLK3_DOUT0_R { 35 | BLK3_DOUT0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata0](index.html) module"] 39 | pub struct BLK3_RDATA0_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata0::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA0 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT1` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT1_R(crate::FieldReader); 18 | impl BLK3_DOUT1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout1(&self) -> BLK3_DOUT1_R { 35 | BLK3_DOUT1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata1](index.html) module"] 39 | pub struct BLK3_RDATA1_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata1::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA1 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT2` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT2_R(crate::FieldReader); 18 | impl BLK3_DOUT2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout2(&self) -> BLK3_DOUT2_R { 35 | BLK3_DOUT2_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata2](index.html) module"] 39 | pub struct BLK3_RDATA2_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata2::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA2 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA5` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT5` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT5_R(crate::FieldReader); 18 | impl BLK3_DOUT5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout5(&self) -> BLK3_DOUT5_R { 35 | BLK3_DOUT5_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata5](index.html) module"] 39 | pub struct BLK3_RDATA5_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA5_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata5::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA5_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA5 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA5_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA6` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT6` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT6_R(crate::FieldReader); 18 | impl BLK3_DOUT6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout6(&self) -> BLK3_DOUT6_R { 35 | BLK3_DOUT6_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata6](index.html) module"] 39 | pub struct BLK3_RDATA6_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA6_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata6::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA6_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA6 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA6_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/blk3_rdata7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `BLK3_RDATA7` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `BLK3_DOUT7` reader - read for BLOCK3"] 17 | pub struct BLK3_DOUT7_R(crate::FieldReader); 18 | impl BLK3_DOUT7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | BLK3_DOUT7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for BLK3_DOUT7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - read for BLOCK3"] 33 | #[inline(always)] 34 | pub fn blk3_dout7(&self) -> BLK3_DOUT7_R { 35 | BLK3_DOUT7_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [blk3_rdata7](index.html) module"] 39 | pub struct BLK3_RDATA7_SPEC; 40 | impl crate::RegisterSpec for BLK3_RDATA7_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [blk3_rdata7::R](R) reader structure"] 44 | impl crate::Readable for BLK3_RDATA7_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets BLK3_RDATA7 to value 0"] 48 | impl crate::Resettable for BLK3_RDATA7_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/flash_encryption/done.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DONE` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `FLASH_DONE` reader - Set this bit when encryption operation is complete."] 17 | pub struct FLASH_DONE_R(crate::FieldReader); 18 | impl FLASH_DONE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: bool) -> Self { 21 | FLASH_DONE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for FLASH_DONE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bit 0 - Set this bit when encryption operation is complete."] 33 | #[inline(always)] 34 | pub fn flash_done(&self) -> FLASH_DONE_R { 35 | FLASH_DONE_R::new((self.bits & 0x01) != 0) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [done](index.html) module"] 39 | pub struct DONE_SPEC; 40 | impl crate::RegisterSpec for DONE_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [done::R](R) reader structure"] 44 | impl crate::Readable for DONE_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DONE to value 0"] 48 | impl crate::Resettable for DONE_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/tcbcnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `TCBCNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `TCBCNT` reader - Number of bytes transferred by CIU unit to card."] 17 | pub struct TCBCNT_R(crate::FieldReader); 18 | impl TCBCNT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | TCBCNT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for TCBCNT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Number of bytes transferred by CIU unit to card."] 33 | #[inline(always)] 34 | pub fn tcbcnt(&self) -> TCBCNT_R { 35 | TCBCNT_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "Transferred byte count register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tcbcnt](index.html) module"] 39 | pub struct TCBCNT_SPEC; 40 | impl crate::RegisterSpec for TCBCNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [tcbcnt::R](R) reader structure"] 44 | impl crate::Readable for TCBCNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets TCBCNT to value 0"] 48 | impl crate::Resettable for TCBCNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/uhci0/rx_head.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RX_HEAD` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RX_HEAD` reader - This register stores the packet header received by DMA"] 17 | pub struct RX_HEAD_R(crate::FieldReader); 18 | impl RX_HEAD_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | RX_HEAD_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for RX_HEAD_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - This register stores the packet header received by DMA"] 33 | #[inline(always)] 34 | pub fn rx_head(&self) -> RX_HEAD_R { 35 | RX_HEAD_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rx_head](index.html) module"] 39 | pub struct RX_HEAD_SPEC; 40 | impl crate::RegisterSpec for RX_HEAD_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [rx_head::R](R) reader structure"] 44 | impl crate::Readable for RX_HEAD_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets RX_HEAD to value 0"] 48 | impl crate::Resettable for RX_HEAD_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/cpusdio_int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CPUSDIO_INT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SDIO_INT` reader - SDIO's extent GPIO0~31 interrupt"] 17 | pub struct SDIO_INT_R(crate::FieldReader); 18 | impl SDIO_INT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SDIO_INT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SDIO_INT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - SDIO's extent GPIO0~31 interrupt"] 33 | #[inline(always)] 34 | pub fn sdio_int(&self) -> SDIO_INT_R { 35 | SDIO_INT_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cpusdio_int](index.html) module"] 39 | pub struct CPUSDIO_INT_SPEC; 40 | impl crate::RegisterSpec for CPUSDIO_INT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [cpusdio_int::R](R) reader structure"] 44 | impl crate::Readable for CPUSDIO_INT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CPUSDIO_INT to value 0"] 48 | impl crate::Resettable for CPUSDIO_INT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/timg0/rtccalicfg1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `RTCCALICFG1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RTC_CALI_VALUE` reader - "] 17 | pub struct RTC_CALI_VALUE_R(crate::FieldReader); 18 | impl RTC_CALI_VALUE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | RTC_CALI_VALUE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for RTC_CALI_VALUE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 7:31"] 33 | #[inline(always)] 34 | pub fn rtc_cali_value(&self) -> RTC_CALI_VALUE_R { 35 | RTC_CALI_VALUE_R::new(((self.bits >> 7) & 0x01ff_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rtccalicfg1](index.html) module"] 39 | pub struct RTCCALICFG1_SPEC; 40 | impl crate::RegisterSpec for RTCCALICFG1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [rtccalicfg1::R](R) reader structure"] 44 | impl crate::Readable for RTCCALICFG1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets RTCCALICFG1 to value 0"] 48 | impl crate::Resettable for RTCCALICFG1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/acpu_int1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `ACPU_INT1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APPCPU_INT_H` reader - GPIO32~39 APP CPU interrupt status"] 17 | pub struct APPCPU_INT_H_R(crate::FieldReader); 18 | impl APPCPU_INT_H_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | APPCPU_INT_H_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APPCPU_INT_H_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:7 - GPIO32~39 APP CPU interrupt status"] 33 | #[inline(always)] 34 | pub fn appcpu_int_h(&self) -> APPCPU_INT_H_R { 35 | APPCPU_INT_H_R::new((self.bits & 0xff) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [acpu_int1](index.html) module"] 39 | pub struct ACPU_INT1_SPEC; 40 | impl crate::RegisterSpec for ACPU_INT1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [acpu_int1::R](R) reader structure"] 44 | impl crate::Readable for ACPU_INT1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets ACPU_INT1 to value 0"] 48 | impl crate::Resettable for ACPU_INT1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/gpio/pcpu_int1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `PCPU_INT1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PROCPU_INT_H` reader - GPIO32~39 PRO CPU interrupt status"] 17 | pub struct PROCPU_INT_H_R(crate::FieldReader); 18 | impl PROCPU_INT_H_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | PROCPU_INT_H_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PROCPU_INT_H_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:7 - GPIO32~39 PRO CPU interrupt status"] 33 | #[inline(always)] 34 | pub fn procpu_int_h(&self) -> PROCPU_INT_H_R { 35 | PROCPU_INT_H_R::new((self.bits & 0xff) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [pcpu_int1](index.html) module"] 39 | pub struct PCPU_INT1_SPEC; 40 | impl crate::RegisterSpec for PCPU_INT1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [pcpu_int1::R](R) reader structure"] 44 | impl crate::Readable for PCPU_INT1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets PCPU_INT1 to value 0"] 48 | impl crate::Resettable for PCPU_INT1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2c0/data.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DATA` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `FIFO_RDATA` reader - The register represent the byte data read from rxfifo when use apb fifo access"] 17 | pub struct FIFO_RDATA_R(crate::FieldReader); 18 | impl FIFO_RDATA_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | FIFO_RDATA_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for FIFO_RDATA_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:7 - The register represent the byte data read from rxfifo when use apb fifo access"] 33 | #[inline(always)] 34 | pub fn fifo_rdata(&self) -> FIFO_RDATA_R { 35 | FIFO_RDATA_R::new((self.bits & 0xff) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [data](index.html) module"] 39 | pub struct DATA_SPEC; 40 | impl crate::RegisterSpec for DATA_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [data::R](R) reader structure"] 44 | impl crate::Readable for DATA_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DATA to value 0"] 48 | impl crate::Resettable for DATA_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/tbbcnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `TBBCNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `TBBCNT` reader - Number of bytes transferred between Host/DMA memory and BIU FIFO."] 17 | pub struct TBBCNT_R(crate::FieldReader); 18 | impl TBBCNT_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | TBBCNT_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for TBBCNT_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Number of bytes transferred between Host/DMA memory and BIU FIFO."] 33 | #[inline(always)] 34 | pub fn tbbcnt(&self) -> TBBCNT_R { 35 | TBBCNT_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "Transferred byte count register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tbbcnt](index.html) module"] 39 | pub struct TBBCNT_SPEC; 40 | impl crate::RegisterSpec for TBBCNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [tbbcnt::R](R) reader structure"] 44 | impl crate::Readable for TBBCNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets TBBCNT to value 0"] 48 | impl crate::Resettable for TBBCNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/uart0/mem_tx_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `MEM_TX_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `MEM_TX_STATUS` reader - "] 17 | pub struct MEM_TX_STATUS_R(crate::FieldReader); 18 | impl MEM_TX_STATUS_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | MEM_TX_STATUS_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for MEM_TX_STATUS_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:23"] 33 | #[inline(always)] 34 | pub fn mem_tx_status(&self) -> MEM_TX_STATUS_R { 35 | MEM_TX_STATUS_R::new((self.bits & 0x00ff_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [mem_tx_status](index.html) module"] 39 | pub struct MEM_TX_STATUS_SPEC; 40 | impl crate::RegisterSpec for MEM_TX_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [mem_tx_status::R](R) reader structure"] 44 | impl crate::Readable for MEM_TX_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets MEM_TX_STATUS to value 0"] 48 | impl crate::Resettable for MEM_TX_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/aes/idle.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `IDLE` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `IDLE` reader - AES Idle register. Reads ’zero’ while the AES Accelerator is busy processing; reads ’one’ otherwise."] 17 | pub struct IDLE_R(crate::FieldReader); 18 | impl IDLE_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: bool) -> Self { 21 | IDLE_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for IDLE_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bit 0 - AES Idle register. Reads ’zero’ while the AES Accelerator is busy processing; reads ’one’ otherwise."] 33 | #[inline(always)] 34 | pub fn idle(&self) -> IDLE_R { 35 | IDLE_R::new((self.bits & 0x01) != 0) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [idle](index.html) module"] 39 | pub struct IDLE_SPEC; 40 | impl crate::RegisterSpec for IDLE_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [idle::R](R) reader structure"] 44 | impl crate::Readable for IDLE_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets IDLE to value 0"] 48 | impl crate::Resettable for IDLE_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u0_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U0_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U0` reader - This register stores the current pulse count value for unit0."] 17 | pub struct PLUS_CNT_U0_R(crate::FieldReader); 18 | impl PLUS_CNT_U0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit0."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u0(&self) -> PLUS_CNT_U0_R { 35 | PLUS_CNT_U0_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u0_cnt](index.html) module"] 39 | pub struct U0_CNT_SPEC; 40 | impl crate::RegisterSpec for U0_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u0_cnt::R](R) reader structure"] 44 | impl crate::Readable for U0_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U0_CNT to value 0"] 48 | impl crate::Resettable for U0_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u1_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U1_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U1` reader - This register stores the current pulse count value for unit1."] 17 | pub struct PLUS_CNT_U1_R(crate::FieldReader); 18 | impl PLUS_CNT_U1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit1."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u1(&self) -> PLUS_CNT_U1_R { 35 | PLUS_CNT_U1_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u1_cnt](index.html) module"] 39 | pub struct U1_CNT_SPEC; 40 | impl crate::RegisterSpec for U1_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u1_cnt::R](R) reader structure"] 44 | impl crate::Readable for U1_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U1_CNT to value 0"] 48 | impl crate::Resettable for U1_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u2_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U2_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U2` reader - This register stores the current pulse count value for unit2."] 17 | pub struct PLUS_CNT_U2_R(crate::FieldReader); 18 | impl PLUS_CNT_U2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit2."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u2(&self) -> PLUS_CNT_U2_R { 35 | PLUS_CNT_U2_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u2_cnt](index.html) module"] 39 | pub struct U2_CNT_SPEC; 40 | impl crate::RegisterSpec for U2_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u2_cnt::R](R) reader structure"] 44 | impl crate::Readable for U2_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U2_CNT to value 0"] 48 | impl crate::Resettable for U2_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u3_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U3_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U3` reader - This register stores the current pulse count value for unit3."] 17 | pub struct PLUS_CNT_U3_R(crate::FieldReader); 18 | impl PLUS_CNT_U3_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U3_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U3_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit3."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u3(&self) -> PLUS_CNT_U3_R { 35 | PLUS_CNT_U3_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u3_cnt](index.html) module"] 39 | pub struct U3_CNT_SPEC; 40 | impl crate::RegisterSpec for U3_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u3_cnt::R](R) reader structure"] 44 | impl crate::Readable for U3_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U3_CNT to value 0"] 48 | impl crate::Resettable for U3_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u4_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U4_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U4` reader - This register stores the current pulse count value for unit4."] 17 | pub struct PLUS_CNT_U4_R(crate::FieldReader); 18 | impl PLUS_CNT_U4_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U4_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U4_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit4."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u4(&self) -> PLUS_CNT_U4_R { 35 | PLUS_CNT_U4_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u4_cnt](index.html) module"] 39 | pub struct U4_CNT_SPEC; 40 | impl crate::RegisterSpec for U4_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u4_cnt::R](R) reader structure"] 44 | impl crate::Readable for U4_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U4_CNT to value 0"] 48 | impl crate::Resettable for U4_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u5_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U5_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U5` reader - This register stores the current pulse count value for unit5."] 17 | pub struct PLUS_CNT_U5_R(crate::FieldReader); 18 | impl PLUS_CNT_U5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit5."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u5(&self) -> PLUS_CNT_U5_R { 35 | PLUS_CNT_U5_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u5_cnt](index.html) module"] 39 | pub struct U5_CNT_SPEC; 40 | impl crate::RegisterSpec for U5_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u5_cnt::R](R) reader structure"] 44 | impl crate::Readable for U5_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U5_CNT to value 0"] 48 | impl crate::Resettable for U5_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u6_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U6_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U6` reader - This register stores the current pulse count value for unit6."] 17 | pub struct PLUS_CNT_U6_R(crate::FieldReader); 18 | impl PLUS_CNT_U6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit6."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u6(&self) -> PLUS_CNT_U6_R { 35 | PLUS_CNT_U6_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u6_cnt](index.html) module"] 39 | pub struct U6_CNT_SPEC; 40 | impl crate::RegisterSpec for U6_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u6_cnt::R](R) reader structure"] 44 | impl crate::Readable for U6_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U6_CNT to value 0"] 48 | impl crate::Resettable for U6_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/pcnt/u7_cnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `U7_CNT` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PLUS_CNT_U7` reader - This register stores the current pulse count value for unit7."] 17 | pub struct PLUS_CNT_U7_R(crate::FieldReader); 18 | impl PLUS_CNT_U7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | PLUS_CNT_U7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PLUS_CNT_U7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:15 - This register stores the current pulse count value for unit7."] 33 | #[inline(always)] 34 | pub fn plus_cnt_u7(&self) -> PLUS_CNT_U7_R { 35 | PLUS_CNT_U7_R::new((self.bits & 0xffff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [u7_cnt](index.html) module"] 39 | pub struct U7_CNT_SPEC; 40 | impl crate::RegisterSpec for U7_CNT_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [u7_cnt::R](R) reader structure"] 44 | impl crate::Readable for U7_CNT_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets U7_CNT to value 0"] 48 | impl crate::Resettable for U7_CNT_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/sdmmc/verid.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `VERID` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `VERSIONID` reader - Hardware version register. Can also be read by fireware."] 17 | pub struct VERSIONID_R(crate::FieldReader); 18 | impl VERSIONID_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | VERSIONID_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for VERSIONID_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - Hardware version register. Can also be read by fireware."] 33 | #[inline(always)] 34 | pub fn versionid(&self) -> VERSIONID_R { 35 | VERSIONID_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "Version ID (scratchpad) register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [verid](index.html) module"] 39 | pub struct VERID_SPEC; 40 | impl crate::RegisterSpec for VERID_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [verid::R](R) reader structure"] 44 | impl crate::Readable for VERID_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets VERID to value 0x5432_270a"] 48 | impl crate::Resettable for VERID_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0x5432_270a 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_0_rxlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_0_RXLINK_DSCR` reader"] 2 | pub struct R(crate::R<_0_RXLINK_DSCR_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_0_RXLINK_DSCR_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_0_RXLINK_DSCR_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC0_RXLINK_DSCR` reader - "] 17 | pub struct SLC0_RXLINK_DSCR_R(crate::FieldReader); 18 | impl SLC0_RXLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC0_RXLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC0_RXLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc0_rxlink_dscr(&self) -> SLC0_RXLINK_DSCR_R { 35 | SLC0_RXLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_0_rxlink_dscr](index.html) module"] 39 | pub struct _0_RXLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for _0_RXLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_0_rxlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for _0_RXLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _0_RXLINK_DSCR to value 0"] 48 | impl crate::Resettable for _0_RXLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_0_txlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_0_TXLINK_DSCR` reader"] 2 | pub struct R(crate::R<_0_TXLINK_DSCR_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_0_TXLINK_DSCR_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_0_TXLINK_DSCR_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC0_TXLINK_DSCR` reader - "] 17 | pub struct SLC0_TXLINK_DSCR_R(crate::FieldReader); 18 | impl SLC0_TXLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC0_TXLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC0_TXLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc0_txlink_dscr(&self) -> SLC0_TXLINK_DSCR_R { 35 | SLC0_TXLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_0_txlink_dscr](index.html) module"] 39 | pub struct _0_TXLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for _0_TXLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_0_txlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for _0_TXLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _0_TXLINK_DSCR to value 0"] 48 | impl crate::Resettable for _0_TXLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_1_rxlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_1_RXLINK_DSCR` reader"] 2 | pub struct R(crate::R<_1_RXLINK_DSCR_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_1_RXLINK_DSCR_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_1_RXLINK_DSCR_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC1_RXLINK_DSCR` reader - "] 17 | pub struct SLC1_RXLINK_DSCR_R(crate::FieldReader); 18 | impl SLC1_RXLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC1_RXLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC1_RXLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc1_rxlink_dscr(&self) -> SLC1_RXLINK_DSCR_R { 35 | SLC1_RXLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_1_rxlink_dscr](index.html) module"] 39 | pub struct _1_RXLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for _1_RXLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_1_rxlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for _1_RXLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _1_RXLINK_DSCR to value 0"] 48 | impl crate::Resettable for _1_RXLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/slc/_1_txlink_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `_1_TXLINK_DSCR` reader"] 2 | pub struct R(crate::R<_1_TXLINK_DSCR_SPEC>); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R<_1_TXLINK_DSCR_SPEC>; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R<_1_TXLINK_DSCR_SPEC>) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `SLC1_TXLINK_DSCR` reader - "] 17 | pub struct SLC1_TXLINK_DSCR_R(crate::FieldReader); 18 | impl SLC1_TXLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | SLC1_TXLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for SLC1_TXLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn slc1_txlink_dscr(&self) -> SLC1_TXLINK_DSCR_R { 35 | SLC1_TXLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [_1_txlink_dscr](index.html) module"] 39 | pub struct _1_TXLINK_DSCR_SPEC; 40 | impl crate::RegisterSpec for _1_TXLINK_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [_1_txlink_dscr::R](R) reader structure"] 44 | impl crate::Readable for _1_TXLINK_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets _1_TXLINK_DSCR to value 0"] 48 | impl crate::Resettable for _1_TXLINK_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/inlink_dscr_bf0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `INLINK_DSCR_BF0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `INLINK_DSCR_BF0` reader - "] 17 | pub struct INLINK_DSCR_BF0_R(crate::FieldReader); 18 | impl INLINK_DSCR_BF0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | INLINK_DSCR_BF0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for INLINK_DSCR_BF0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn inlink_dscr_bf0(&self) -> INLINK_DSCR_BF0_R { 35 | INLINK_DSCR_BF0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [inlink_dscr_bf0](index.html) module"] 39 | pub struct INLINK_DSCR_BF0_SPEC; 40 | impl crate::RegisterSpec for INLINK_DSCR_BF0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [inlink_dscr_bf0::R](R) reader structure"] 44 | impl crate::Readable for INLINK_DSCR_BF0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets INLINK_DSCR_BF0 to value 0"] 48 | impl crate::Resettable for INLINK_DSCR_BF0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/inlink_dscr_bf1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `INLINK_DSCR_BF1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `INLINK_DSCR_BF1` reader - "] 17 | pub struct INLINK_DSCR_BF1_R(crate::FieldReader); 18 | impl INLINK_DSCR_BF1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | INLINK_DSCR_BF1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for INLINK_DSCR_BF1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn inlink_dscr_bf1(&self) -> INLINK_DSCR_BF1_R { 35 | INLINK_DSCR_BF1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [inlink_dscr_bf1](index.html) module"] 39 | pub struct INLINK_DSCR_BF1_SPEC; 40 | impl crate::RegisterSpec for INLINK_DSCR_BF1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [inlink_dscr_bf1::R](R) reader structure"] 44 | impl crate::Readable for INLINK_DSCR_BF1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets INLINK_DSCR_BF1 to value 0"] 48 | impl crate::Resettable for INLINK_DSCR_BF1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/spi0/dma_tstatus.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DMA_TSTATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DMA_IN_STATUS` reader - spi dma write data to memory status."] 17 | pub struct DMA_IN_STATUS_R(crate::FieldReader); 18 | impl DMA_IN_STATUS_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | DMA_IN_STATUS_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DMA_IN_STATUS_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - spi dma write data to memory status."] 33 | #[inline(always)] 34 | pub fn dma_in_status(&self) -> DMA_IN_STATUS_R { 35 | DMA_IN_STATUS_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dma_tstatus](index.html) module"] 39 | pub struct DMA_TSTATUS_SPEC; 40 | impl crate::RegisterSpec for DMA_TSTATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [dma_tstatus::R](R) reader structure"] 44 | impl crate::Readable for DMA_TSTATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DMA_TSTATUS to value 0"] 48 | impl crate::Resettable for DMA_TSTATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch0addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH0ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH0` reader - The ram relative address in channel0 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH0_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel0 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch0(&self) -> APB_MEM_ADDR_CH0_R { 35 | APB_MEM_ADDR_CH0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch0addr](index.html) module"] 39 | pub struct CH0ADDR_SPEC; 40 | impl crate::RegisterSpec for CH0ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch0addr::R](R) reader structure"] 44 | impl crate::Readable for CH0ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH0ADDR to value 0"] 48 | impl crate::Resettable for CH0ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch1addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH1ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH1` reader - The ram relative address in channel1 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH1_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel1 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch1(&self) -> APB_MEM_ADDR_CH1_R { 35 | APB_MEM_ADDR_CH1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch1addr](index.html) module"] 39 | pub struct CH1ADDR_SPEC; 40 | impl crate::RegisterSpec for CH1ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch1addr::R](R) reader structure"] 44 | impl crate::Readable for CH1ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH1ADDR to value 0"] 48 | impl crate::Resettable for CH1ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch2addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH2ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH2` reader - The ram relative address in channel2 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH2_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH2_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH2_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH2_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel2 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch2(&self) -> APB_MEM_ADDR_CH2_R { 35 | APB_MEM_ADDR_CH2_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch2addr](index.html) module"] 39 | pub struct CH2ADDR_SPEC; 40 | impl crate::RegisterSpec for CH2ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch2addr::R](R) reader structure"] 44 | impl crate::Readable for CH2ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH2ADDR to value 0"] 48 | impl crate::Resettable for CH2ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch3addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH3ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH3` reader - The ram relative address in channel3 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH3_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH3_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH3_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH3_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel3 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch3(&self) -> APB_MEM_ADDR_CH3_R { 35 | APB_MEM_ADDR_CH3_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch3addr](index.html) module"] 39 | pub struct CH3ADDR_SPEC; 40 | impl crate::RegisterSpec for CH3ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch3addr::R](R) reader structure"] 44 | impl crate::Readable for CH3ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH3ADDR to value 0"] 48 | impl crate::Resettable for CH3ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch4addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH4ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH4` reader - The ram relative address in channel4 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH4_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH4_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH4_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH4_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel4 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch4(&self) -> APB_MEM_ADDR_CH4_R { 35 | APB_MEM_ADDR_CH4_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch4addr](index.html) module"] 39 | pub struct CH4ADDR_SPEC; 40 | impl crate::RegisterSpec for CH4ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch4addr::R](R) reader structure"] 44 | impl crate::Readable for CH4ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH4ADDR to value 0"] 48 | impl crate::Resettable for CH4ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch5addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH5ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH5` reader - The ram relative address in channel5 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH5_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH5_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH5_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH5_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel5 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch5(&self) -> APB_MEM_ADDR_CH5_R { 35 | APB_MEM_ADDR_CH5_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch5addr](index.html) module"] 39 | pub struct CH5ADDR_SPEC; 40 | impl crate::RegisterSpec for CH5ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch5addr::R](R) reader structure"] 44 | impl crate::Readable for CH5ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH5ADDR to value 0"] 48 | impl crate::Resettable for CH5ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch6addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH6ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH6` reader - The ram relative address in channel6 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH6_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH6_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH6_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH6_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel6 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch6(&self) -> APB_MEM_ADDR_CH6_R { 35 | APB_MEM_ADDR_CH6_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch6addr](index.html) module"] 39 | pub struct CH6ADDR_SPEC; 40 | impl crate::RegisterSpec for CH6ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch6addr::R](R) reader structure"] 44 | impl crate::Readable for CH6ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH6ADDR to value 0"] 48 | impl crate::Resettable for CH6ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rmt/ch7addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `CH7ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APB_MEM_ADDR_CH7` reader - The ram relative address in channel7 by apb fifo access"] 17 | pub struct APB_MEM_ADDR_CH7_R(crate::FieldReader); 18 | impl APB_MEM_ADDR_CH7_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APB_MEM_ADDR_CH7_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APB_MEM_ADDR_CH7_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The ram relative address in channel7 by apb fifo access"] 33 | #[inline(always)] 34 | pub fn apb_mem_addr_ch7(&self) -> APB_MEM_ADDR_CH7_R { 35 | APB_MEM_ADDR_CH7_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ch7addr](index.html) module"] 39 | pub struct CH7ADDR_SPEC; 40 | impl crate::RegisterSpec for CH7ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [ch7addr::R](R) reader structure"] 44 | impl crate::Readable for CH7ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets CH7ADDR to value 0"] 48 | impl crate::Resettable for CH7ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/spi0/dma_rstatus.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DMA_RSTATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DMA_OUT_STATUS` reader - spi dma read data from memory status."] 17 | pub struct DMA_OUT_STATUS_R(crate::FieldReader); 18 | impl DMA_OUT_STATUS_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | DMA_OUT_STATUS_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DMA_OUT_STATUS_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - spi dma read data from memory status."] 33 | #[inline(always)] 34 | pub fn dma_out_status(&self) -> DMA_OUT_STATUS_R { 35 | DMA_OUT_STATUS_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dma_rstatus](index.html) module"] 39 | pub struct DMA_RSTATUS_SPEC; 40 | impl crate::RegisterSpec for DMA_RSTATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [dma_rstatus::R](R) reader structure"] 44 | impl crate::Readable for DMA_RSTATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DMA_RSTATUS to value 0"] 48 | impl crate::Resettable for DMA_RSTATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/out_eof_des_addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `OUT_EOF_DES_ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `OUT_EOF_DES_ADDR` reader - "] 17 | pub struct OUT_EOF_DES_ADDR_R(crate::FieldReader); 18 | impl OUT_EOF_DES_ADDR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | OUT_EOF_DES_ADDR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for OUT_EOF_DES_ADDR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn out_eof_des_addr(&self) -> OUT_EOF_DES_ADDR_R { 35 | OUT_EOF_DES_ADDR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [out_eof_des_addr](index.html) module"] 39 | pub struct OUT_EOF_DES_ADDR_SPEC; 40 | impl crate::RegisterSpec for OUT_EOF_DES_ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [out_eof_des_addr::R](R) reader structure"] 44 | impl crate::Readable for OUT_EOF_DES_ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets OUT_EOF_DES_ADDR to value 0"] 48 | impl crate::Resettable for OUT_EOF_DES_ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/outlink_dscr_bf0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `OUTLINK_DSCR_BF0` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `OUTLINK_DSCR_BF0` reader - "] 17 | pub struct OUTLINK_DSCR_BF0_R(crate::FieldReader); 18 | impl OUTLINK_DSCR_BF0_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | OUTLINK_DSCR_BF0_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for OUTLINK_DSCR_BF0_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn outlink_dscr_bf0(&self) -> OUTLINK_DSCR_BF0_R { 35 | OUTLINK_DSCR_BF0_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [outlink_dscr_bf0](index.html) module"] 39 | pub struct OUTLINK_DSCR_BF0_SPEC; 40 | impl crate::RegisterSpec for OUTLINK_DSCR_BF0_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [outlink_dscr_bf0::R](R) reader structure"] 44 | impl crate::Readable for OUTLINK_DSCR_BF0_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets OUTLINK_DSCR_BF0 to value 0"] 48 | impl crate::Resettable for OUTLINK_DSCR_BF0_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/outlink_dscr_bf1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `OUTLINK_DSCR_BF1` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `OUTLINK_DSCR_BF1` reader - "] 17 | pub struct OUTLINK_DSCR_BF1_R(crate::FieldReader); 18 | impl OUTLINK_DSCR_BF1_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | OUTLINK_DSCR_BF1_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for OUTLINK_DSCR_BF1_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn outlink_dscr_bf1(&self) -> OUTLINK_DSCR_BF1_R { 35 | OUTLINK_DSCR_BF1_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [outlink_dscr_bf1](index.html) module"] 39 | pub struct OUTLINK_DSCR_BF1_SPEC; 40 | impl crate::RegisterSpec for OUTLINK_DSCR_BF1_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [outlink_dscr_bf1::R](R) reader structure"] 44 | impl crate::Readable for OUTLINK_DSCR_BF1_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets OUTLINK_DSCR_BF1 to value 0"] 48 | impl crate::Resettable for OUTLINK_DSCR_BF1_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/efuse/dec_status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DEC_STATUS` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `DEC_WARNINGS` reader - the decode result of 3/4 coding scheme has warning"] 17 | pub struct DEC_WARNINGS_R(crate::FieldReader); 18 | impl DEC_WARNINGS_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u16) -> Self { 21 | DEC_WARNINGS_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for DEC_WARNINGS_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:11 - the decode result of 3/4 coding scheme has warning"] 33 | #[inline(always)] 34 | pub fn dec_warnings(&self) -> DEC_WARNINGS_R { 35 | DEC_WARNINGS_R::new((self.bits & 0x0fff) as u16) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dec_status](index.html) module"] 39 | pub struct DEC_STATUS_SPEC; 40 | impl crate::RegisterSpec for DEC_STATUS_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [dec_status::R](R) reader structure"] 44 | impl crate::Readable for DEC_STATUS_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DEC_STATUS to value 0"] 48 | impl crate::Resettable for DEC_STATUS_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/dport/app_dcache_dbug2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `APP_DCACHE_DBUG2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `APP_CACHE_VADDR` reader - "] 17 | pub struct APP_CACHE_VADDR_R(crate::FieldReader); 18 | impl APP_CACHE_VADDR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | APP_CACHE_VADDR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for APP_CACHE_VADDR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:26"] 33 | #[inline(always)] 34 | pub fn app_cache_vaddr(&self) -> APP_CACHE_VADDR_R { 35 | APP_CACHE_VADDR_R::new((self.bits & 0x07ff_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [app_dcache_dbug2](index.html) module"] 39 | pub struct APP_DCACHE_DBUG2_SPEC; 40 | impl crate::RegisterSpec for APP_DCACHE_DBUG2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [app_dcache_dbug2::R](R) reader structure"] 44 | impl crate::Readable for APP_DCACHE_DBUG2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets APP_DCACHE_DBUG2 to value 0"] 48 | impl crate::Resettable for APP_DCACHE_DBUG2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/dport/pro_dcache_dbug2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `PRO_DCACHE_DBUG2` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `PRO_CACHE_VADDR` reader - "] 17 | pub struct PRO_CACHE_VADDR_R(crate::FieldReader); 18 | impl PRO_CACHE_VADDR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | PRO_CACHE_VADDR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for PRO_CACHE_VADDR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:26"] 33 | #[inline(always)] 34 | pub fn pro_cache_vaddr(&self) -> PRO_CACHE_VADDR_R { 35 | PRO_CACHE_VADDR_R::new((self.bits & 0x07ff_ffff) as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [pro_dcache_dbug2](index.html) module"] 39 | pub struct PRO_DCACHE_DBUG2_SPEC; 40 | impl crate::RegisterSpec for PRO_DCACHE_DBUG2_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [pro_dcache_dbug2::R](R) reader structure"] 44 | impl crate::Readable for PRO_DCACHE_DBUG2_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets PRO_DCACHE_DBUG2 to value 0"] 48 | impl crate::Resettable for PRO_DCACHE_DBUG2_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/i2s0/in_eof_des_addr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `IN_EOF_DES_ADDR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `IN_SUC_EOF_DES_ADDR` reader - "] 17 | pub struct IN_SUC_EOF_DES_ADDR_R(crate::FieldReader); 18 | impl IN_SUC_EOF_DES_ADDR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | IN_SUC_EOF_DES_ADDR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for IN_SUC_EOF_DES_ADDR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31"] 33 | #[inline(always)] 34 | pub fn in_suc_eof_des_addr(&self) -> IN_SUC_EOF_DES_ADDR_R { 35 | IN_SUC_EOF_DES_ADDR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [in_eof_des_addr](index.html) module"] 39 | pub struct IN_EOF_DES_ADDR_SPEC; 40 | impl crate::RegisterSpec for IN_EOF_DES_ADDR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [in_eof_des_addr::R](R) reader structure"] 44 | impl crate::Readable for IN_EOF_DES_ADDR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets IN_EOF_DES_ADDR to value 0"] 48 | impl crate::Resettable for IN_EOF_DES_ADDR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/uhci0/dma_in_dscr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `DMA_IN_DSCR` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `INLINK_DSCR` reader - The content of current in link descriptor's third dword"] 17 | pub struct INLINK_DSCR_R(crate::FieldReader); 18 | impl INLINK_DSCR_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u32) -> Self { 21 | INLINK_DSCR_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for INLINK_DSCR_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:31 - The content of current in link descriptor's third dword"] 33 | #[inline(always)] 34 | pub fn inlink_dscr(&self) -> INLINK_DSCR_R { 35 | INLINK_DSCR_R::new(self.bits as u32) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [dma_in_dscr](index.html) module"] 39 | pub struct DMA_IN_DSCR_SPEC; 40 | impl crate::RegisterSpec for DMA_IN_DSCR_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [dma_in_dscr::R](R) reader structure"] 44 | impl crate::Readable for DMA_IN_DSCR_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets DMA_IN_DSCR to value 0"] 48 | impl crate::Resettable for DMA_IN_DSCR_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/dport/app_cpu_record_pid.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Register `APP_CPU_RECORD_PID` reader"] 2 | pub struct R(crate::R); 3 | impl core::ops::Deref for R { 4 | type Target = crate::R; 5 | #[inline(always)] 6 | fn deref(&self) -> &Self::Target { 7 | &self.0 8 | } 9 | } 10 | impl From> for R { 11 | #[inline(always)] 12 | fn from(reader: crate::R) -> Self { 13 | R(reader) 14 | } 15 | } 16 | #[doc = "Field `RECORD_APP_PID` reader - "] 17 | pub struct RECORD_APP_PID_R(crate::FieldReader); 18 | impl RECORD_APP_PID_R { 19 | #[inline(always)] 20 | pub(crate) fn new(bits: u8) -> Self { 21 | RECORD_APP_PID_R(crate::FieldReader::new(bits)) 22 | } 23 | } 24 | impl core::ops::Deref for RECORD_APP_PID_R { 25 | type Target = crate::FieldReader; 26 | #[inline(always)] 27 | fn deref(&self) -> &Self::Target { 28 | &self.0 29 | } 30 | } 31 | impl R { 32 | #[doc = "Bits 0:2"] 33 | #[inline(always)] 34 | pub fn record_app_pid(&self) -> RECORD_APP_PID_R { 35 | RECORD_APP_PID_R::new((self.bits & 0x07) as u8) 36 | } 37 | } 38 | #[doc = "\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [app_cpu_record_pid](index.html) module"] 39 | pub struct APP_CPU_RECORD_PID_SPEC; 40 | impl crate::RegisterSpec for APP_CPU_RECORD_PID_SPEC { 41 | type Ux = u32; 42 | } 43 | #[doc = "`read()` method returns [app_cpu_record_pid::R](R) reader structure"] 44 | impl crate::Readable for APP_CPU_RECORD_PID_SPEC { 45 | type Reader = R; 46 | } 47 | #[doc = "`reset()` method sets APP_CPU_RECORD_PID to value 0"] 48 | impl crate::Resettable for APP_CPU_RECORD_PID_SPEC { 49 | #[inline(always)] 50 | fn reset_value() -> Self::Ux { 51 | 0 52 | } 53 | } 54 | --------------------------------------------------------------------------------